repo stringclasses 454
values | file_path stringlengths 5 201 | extension stringclasses 1
value | content stringlengths 8 509k | num_lines int64 3 16.9k | size_bytes int64 8 511k |
|---|---|---|---|---|---|
qutip | qutip/core/properties.py | .py | from . import Qobj, QobjEvo
__all__ = [
'isbra', 'isket', 'isoper', 'issuper', 'isoperbra', 'isoperket', 'isherm'
]
def isbra(x: Qobj | QobjEvo) -> bool:
return isinstance(x, (Qobj, QobjEvo)) and x.type in ['bra', 'scalar']
def isket(x: Qobj | QobjEvo) -> bool:
return isinstance(x, (Qobj, QobjEvo)) and... | 36 | 966 |
qutip | qutip/core/subsystem_apply.py | .py | #
# 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: Qobj,
chan... | 218 | 7,680 |
qutip | qutip/core/dimensions.py | .py | """
Internal use module for manipulating dims specifications.
"""
# Required for Sphinx to follow autodoc_type_aliases
from __future__ import annotations
from collections.abc import Sequence
import numpy as np
import numbers
from operator import getitem
from functools import partial
from typing import Any, Literal
fro... | 1,147 | 37,158 |
qutip | qutip/core/coefficient.py | .py | # Required for Sphinx to follow autodoc_type_aliases
from __future__ import annotations
import os
import numpy as np
from numpy.typing import ArrayLike
import scipy
import scipy.interpolate
import sys
import re
import dis
import hashlib
import glob
import importlib
import warnings
import numbers
from collections impor... | 867 | 28,128 |
qutip | qutip/core/gates.py | .py | # Required for Sphinx to follow autodoc_type_aliases
from __future__ import annotations
from itertools import product
from functools import partial, reduce
from operator import mul
import numpy as np
from . import Qobj, qeye, sigmax, fock_dm, qdiags, qeye_like
from .dimensions import Dimensions
from .. import setting... | 844 | 21,705 |
qutip | qutip/core/metrics.py | .py | """
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']
f... | 607 | 20,609 |
qutip | qutip/core/expect.py | .py | __all__ = ['expect', 'variance']
from typing import overload, Sequence
from .qobj import Qobj
from . import data as _data
from ..settings import settings
from ..core.numpy_backend import np
@overload
def expect(oper: Qobj, state: Qobj) -> complex: ...
@overload
def expect(
oper: Qobj,
state: Qobj | Sequence... | 129 | 3,537 |
qutip | qutip/core/energy_restricted.py | .py | from .dimensions import Space
from .states import state_number_enumerate
from . import data as _data
from . import Qobj, qdiags
import numpy as np
import scipy.sparse
from .. import settings
import math
import numbers
import itertools
import warnings
__all__ = ['enr_state_dictionaries', 'enr_nstates',
'enr_... | 552 | 19,003 |
qutip | qutip/core/qobj.py | .py | """The Quantum Object (Qobj) class, for representing quantum states and
operators, and related functions.
"""
from __future__ import annotations
import functools
import numbers
import warnings
from typing import Any, Literal, TypeVar, Union, overload
from collections.abc import Callable
import numpy as np
from numpy.t... | 2,127 | 74,919 |
qutip | qutip/core/states.py | .py | # Required for Sphinx to follow autodoc_type_aliases
from __future__ import annotations
__all__ = ['basis', 'qutrit_basis', 'coherent', 'coherent_dm', 'fock_dm',
'fock', 'thermal_dm', 'maximally_mixed_dm', 'ket2dm', 'projection',
'qstate', 'ket', 'bra', 'state_number_enumerate',
'state... | 1,420 | 40,836 |
qutip | qutip/core/cy/openmp/bench_openmp.py | .py | 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)
ret... | 155 | 4,640 |
qutip | qutip/core/cy/openmp/utilities.py | .py | 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:
option... | 42 | 1,164 |
qutip | qutip/core/data/eigen.py | .py | 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, nnz
from .properties import isherm as _isherm
from qutip.settings import settings
__all__ = [
'eigs', 'eigs_csr', 'eigs_dense',
... | 467 | 15,513 |
qutip | qutip/core/data/make.py | .py | from .dispatch import Dispatcher as _Dispatcher
from . import csr, dense, dia, CSR, Dense, Dia
import numpy as np
__all__ = [
'diag',
'one_element_csr', 'one_element_dense', 'one_element_dia', 'one_element'
]
def _diag_signature(diagonals, offsets=0, shape=None):
"""
Construct a matrix from diagonals... | 132 | 4,361 |
qutip | qutip/core/data/_scipy_sparse.py | .py | """
Helper module for the use of ``scipy.sparse`` backing containers in the
data layer.
In the light of SciPy's migration plans, ``spmatrix`` types (``csr_matrix``,
``dia_matrix``, ...) will be replaced by ``sparray`` types.
We respond to this by ensuring that qutip's data layer always uses ``sparray``
containers inte... | 102 | 3,229 |
qutip | qutip/core/data/extract.py | .py | from . import Dense, CSR, Dia
from .dispatch import Dispatcher as _Dispatcher
from ._scipy_sparse import csr_as_matrix, dia_as_matrix
import inspect as _inspect
__all__ = ["extract"]
def extract_dense(matrix, format=None, copy=True):
"""
Return an array representation of the Dense data object.
Paramete... | 146 | 4,691 |
qutip | qutip/core/data/local_matmul.py | .py | import itertools
import math
import numpy as np
from . import Data, Dense, CSR, Dia
from qutip.core.data._local_matmul import (
one_mode_matmul_data_dense,
one_mode_matmul_dual_dense_data,
n_mode_matmul_data_dense,
_flatten_view_dense, _unflatten_view_dense
)
__all__ = ["target_mode_matmul", "target_... | 248 | 7,652 |
qutip | qutip/core/data/__init__.py | .py | # First-class type imports
from . import dense, csr
from .dense import Dense
from .csr import CSR
from .dia import Dia
from .base import Data
from .add import *
from .adjoint import *
from .block_operations import *
from .constant import *
from .eigen import *
from .expect import *
from .expm import *
from .inner imp... | 71 | 1,882 |
qutip | qutip/core/data/expm.py | .py | import numpy as np
import scipy.sparse.linalg
import scipy.linalg
from .eigen import eigs_dense
from .dense import Dense
from .csr import CSR
from .dia import Dia
from . import dia
from .make import diag
from .matmul import matmul_dense, matmul_dag_dense
from .properties import isdiag_csr, isdiag_dia, isherm_dense
fro... | 172 | 5,439 |
qutip | qutip/core/data/constant.py | .py | # 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, dia
from .csr import CSR
... | 137 | 3,807 |
qutip | qutip/core/data/linalg.py | .py | 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 "
... | 59 | 1,658 |
qutip | qutip/core/data/_creator_utils.py | .py | """
Define functions to use as Data creator for `create` in `convert.py`.
"""
import numpy as np
from .csr import CSR
from .base import Data
from .dense import Dense
from ._scipy_sparse import is_csr, is_dia, issparse
__all__ = [
'data_copy',
'is_data',
'is_nparray',
'is_csr',
'is_dia',
'isspa... | 39 | 724 |
qutip | qutip/core/data/solve.py | .py | 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
from qutip.settings import settings
import warnings
from typing import Union
if settings.has_mkl:
from qutip._mkl.spsolve import mkl_spsolve
else:
mkl_spsolve = None
... | 235 | 6,767 |
qutip | qutip/tests/test_simdiag.py | .py | 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)... | 122 | 3,800 |
qutip | qutip/tests/test_utilities.py | .py | 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... | 269 | 10,187 |
qutip | qutip/tests/test_ipynbtools.py | .py | import pytest
pytest.importorskip("IPython")
from qutip.ipynbtools import version_table
@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
ass... | 26 | 906 |
qutip | qutip/tests/test_bloch.py | .py | import copy
import numpy as np
import pytest
from qutip.bloch import Bloch, _state_to_cartesian_coordinates
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... | 748 | 29,318 |
qutip | qutip/tests/test_visualization.py | .py | import pytest
import qutip
import numpy as np
from qutip.wigner import sph_harm_y
mpl = pytest.importorskip("matplotlib")
plt = pytest.importorskip("matplotlib.pyplot")
def test_cyclic():
qutip.settings.colorblind_safe = True
rho = qutip.rand_dm(5)
fig, ax = qutip.hinton(rho, color_style='phase')
plt... | 715 | 19,618 |
qutip | qutip/tests/test_progressbar.py | .py | from qutip.ui.progressbar import progress_bars
import pytest
import time
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("h... | 69 | 1,505 |
qutip | qutip/tests/test_qpt.py | .py | import numpy as np
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)... | 47 | 1,350 |
qutip | qutip/tests/test_qip.py | .py | 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.mkdi... | 47 | 1,373 |
qutip | qutip/tests/test_animation.py | .py | import pytest
import qutip
import numpy as np
from qutip.wigner import sph_harm_y
mpl = pytest.importorskip("matplotlib")
plt = pytest.importorskip("matplotlib.pyplot")
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 = qut... | 148 | 3,863 |
qutip | qutip/tests/test_basis_transformation.py | .py | 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 + qob... | 56 | 2,076 |
qutip | qutip/tests/test_about.py | .py | import qutip
def test_qutip_about(capsys):
qutip.about()
outerr = capsys.readouterr()
out = outerr.out.splitlines()
assert out[:3] == [
"",
"QuTiP: Quantum Toolbox in Python",
"================================",
]
assert out[-3:] == [
"Please cite QuTiP in your ... | 19 | 557 |
qutip | qutip/tests/test_partial_transpose.py | .py | """
Unit tests for QuTiP partial transpose functions.
"""
import numpy as np
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(... | 74 | 2,523 |
qutip | qutip/tests/test_entropy.py | .py | import pytest
import numpy as np
import qutip
from qutip.core.energy_restricted import EnrSpace
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.... | 238 | 9,189 |
qutip | qutip/tests/test_mkl.py | .py | 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... | 117 | 3,624 |
qutip | qutip/tests/test_subsys_apply.py | .py | from numpy.linalg import norm
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 superop... | 117 | 4,569 |
qutip | qutip/tests/test_fileio.py | .py | 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
# d... | 63 | 2,337 |
qutip | qutip/tests/test_measurement.py | .py | from math import sqrt
import numpy as np
import pytest
from qutip import CoreOptions
from qutip import basis, identity, ket2dm, num, sigmax, sigmay, sigmaz
from qutip.measurement import (
measure_observable,
measure_povm,
measurement_statistics_observable,
measurement_statistics_povm,
)
class EigenP... | 363 | 14,459 |
qutip | qutip/tests/test_random.py | .py | import numpy as np
from numpy.random import SeedSequence, default_rng
import pytest
from qutip import qeye, to_kraus, kraus_to_choi, CoreOptions, Qobj
from qutip import data as _data
from qutip.core.dimensions import Space
from qutip.core.energy_restricted import EnrSpace
from qutip.random_objects import (
rand_he... | 334 | 10,151 |
qutip | qutip/tests/test_openmp.py | .py | import numpy as np
from numpy.testing import assert_equal
import pytest
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.')
@pytest.mark.skipi... | 112 | 3,882 |
qutip | qutip/tests/test_distributions.py | .py | import numpy as np
from qutip import basis, tensor
import pytest
from qutip.distributions import (
TwoModeQuadratureCorrelation, HarmonicOscillatorWaveFunction,
HarmonicOscillatorProbabilityFunction
)
# Fixtures provide reusable test data for the test functions below.
@pytest.fixture
def harmonic_oscillator_g... | 212 | 6,849 |
qutip | qutip/tests/test_wigner.py | .py | import pytest
import numpy as np
from scipy.integrate import trapezoid
import itertools
from scipy.special import laguerre
from numpy.random import rand
from numpy.testing import assert_equal, assert_almost_equal, assert_allclose
import qutip
from qutip.core.states import coherent, fock, ket, bell_state
from qutip.wig... | 793 | 28,952 |
qutip | qutip/tests/conftest.py | .py | 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... | 60 | 1,927 |
qutip | qutip/tests/solver/test_integrator.py | .py | 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 *
from qutip.solver.integrator._rhs import RHS
import qutip
import qutip.core.data as _data
import functools
impo... | 297 | 10,681 |
qutip | qutip/tests/solver/test_transfertensor.py | .py | import pytest
import qutip
import numpy as np
from qutip.solver.nonmarkov.transfertensor import ttmsolve
@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-note... | 54 | 1,998 |
qutip | qutip/tests/solver/test_sode_method.py | .py | 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)
import qutip.solver.sode._sode as _sode
import pytest
from qutip.solver.sode.ssystem import (
SimpleStoc... | 202 | 7,772 |
qutip | qutip/tests/solver/test_dysolve_propagator.py | .py | from qutip.solver.dysolve_propagator import DysolvePropagator, dysolve_propagator
from qutip.solver import propagator
from qutip.solver.cy.dysolve import cy_compute_integrals
from qutip import (
sigmax, sigmay, sigmaz, qeye, qeye_like, tensor, enr_destroy, CoreOptions
)
from scipy.special import factorial
import nu... | 367 | 9,881 |
qutip | qutip/tests/solver/test_steadystate.py | .py | import numpy as np
import scipy
import pytest
import qutip
import warnings
from packaging import version as pac_version
from qutip.solver.steadystate import _permute_rcm, _permute_wbm
import qutip.core.data as _data
@pytest.mark.parametrize(['method', 'kwargs'], [
pytest.param('direct', {}, id="direct"),
pyte... | 340 | 12,281 |
qutip | qutip/tests/solver/test_parallel.py | .py | import numpy as np
import time
import pytest
import threading
from qutip.solver.parallel import (
parallel_map, serial_map, loky_pmap, mpi_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... | 165 | 4,528 |
qutip | qutip/tests/solver/test_nm_mcsolve.py | .py | from copy import copy
import numpy as np
import pytest
import qutip
from qutip.solver.nm_mcsolve import nm_mcsolve, NonMarkovianMCSolver
@pytest.mark.slow
@pytest.mark.parametrize("improved_sampling", [True, False])
@pytest.mark.parametrize("mixed_initial_state", [True, False])
def test_agreement_with_mesolve_for_n... | 832 | 30,534 |
qutip | qutip/tests/solver/test_brmesolve.py | .py | import pytest
import numpy as np
import qutip
from qutip.solver.brmesolve import brmesolve
from qutip.core.environment import (
DrudeLorentzEnvironment, LorentzianEnvironment
)
def pauli_spin_operators():
return [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
_simple_qubit_gamma = 0.25
coeff = qutip.coeffi... | 394 | 13,266 |
qutip | qutip/tests/solver/test_stochastic.py | .py | import pytest
import numpy as np
from qutip import (
mesolve, liouvillian, QobjEvo, spre, spost, CoreOptions,
destroy, coherent, qeye, fock_dm, num, basis
)
from qutip.solver.stochastic import smesolve, ssesolve, SMESolver, SSESolver
from qutip.core import data as _data
def f(t, w):
return w * t
def _mak... | 587 | 17,241 |
qutip | qutip/tests/solver/test_sesolve.py | .py | 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
# Deactivate warning for test without cython
from qutip.core.coefficient import WARN_MISSING_MODULE
WARN_MISSING_MO... | 341 | 13,207 |
qutip | qutip/tests/solver/test_correlation.py | .py | import pytest
import functools
from itertools import product
import numpy as np
from scipy.integrate import trapezoid
import qutip
pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
_equivalence_dimension = 15
_equivalence_fock = qutip.fock(_equivalence_dimension, 1)
_equivalence_coherent = qutip.cohere... | 477 | 18,013 |
qutip | qutip/tests/solver/test_qubit_evolution.py | .py | 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.appe... | 125 | 3,608 |
qutip | qutip/tests/solver/test_countstat.py | .py | import numpy as np
import qutip
import pytest
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.project... | 138 | 4,512 |
qutip | qutip/tests/solver/test_lindblad_matrix_form.py | .py | """
Tests for LindbladMatrixForm class.
"""
import numpy as np
import pytest
from numpy.testing import assert_allclose
import qutip
from qutip.core.cy.lindblad_matrix_form import LindbladMatrixForm
from qutip.core.cy.qobjevo import QobjEvo
from qutip.core.data import dense
class TestLindbladMatrixFormInit:
"""Te... | 173 | 5,419 |
qutip | qutip/tests/solver/test_propagator.py | .py | from unittest.mock import patch
import numpy as np
from scipy.integrate import trapezoid
from qutip import (destroy, propagator, Propagator, propagator_steadystate,
steadystate, tensor, qeye, basis, QobjEvo, sesolve,
liouvillian, rand_dm, enr_identity, enr_destroy)
import qutip
imp... | 394 | 10,352 |
qutip | qutip/tests/solver/test_mcsolve.py | .py | import pytest
import numpy as np
import qutip
from copy import copy
from qutip.solver.mcsolve import mcsolve, MCSolver
def _return_constant(t, constant):
return constant
def _return_decay(t, constant, rate):
return constant * np.exp(-rate * t)
class callable_qobj:
def __init__(self, oper, coeff=None):... | 693 | 27,800 |
qutip | qutip/tests/solver/test_scattering.py | .py | """
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 qutip import create, destroy, basis
from qutip.solver.scattering import *
... | 92 | 3,405 |
qutip | qutip/tests/solver/test_floquet.py | .py | 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, fses... | 343 | 12,011 |
qutip | qutip/tests/solver/test_results.py | .py | import numpy as np
import pytest
import qutip
from qutip.solver.result import Result
from qutip.solver.multitrajresult import MultiTrajResult, McResult, NmmcResult
def fill_options(**kwargs):
return {
"store_states": None,
"store_final_state": False,
"keep_runs_results": False,
**... | 765 | 28,301 |
qutip | qutip/tests/solver/test_stochastic_system.py | .py | import numpy as np
from qutip import (
qeye, num, destroy, create, QobjEvo, Qobj,
basis, rand_herm, fock_dm, liouvillian, operator_to_vector
)
from qutip.solver.sode.ssystem import *
from qutip.solver.sode.ssystem import SimpleStochasticSystem, StochasticClosedSystem
import qutip.core.data as _data
import pytes... | 180 | 5,657 |
qutip | qutip/tests/solver/test_mesolve.py | .py | import numpy as np
from types import FunctionType
import qutip
from qutip.solver.mesolve import mesolve, MESolver
from qutip.solver.krylovsolve import krylovsolve
from qutip.solver.solver_base import Solver
import pickle
import pytest
# Deactivate warning for test without cython
from qutip.core.coefficient import WAR... | 977 | 37,228 |
qutip | qutip/tests/solver/test_options.py | .py | 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 o... | 145 | 4,030 |
qutip | qutip/tests/solver/heom/test_bofin_solvers.py | .py | """
Tests for qutip.solver.heom.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, sigmay,
tensor, Qobj, QobjEvo, fidelity, fdestroy
)
from qutip.core import data ... | 1,926 | 68,488 |
qutip | qutip/tests/solver/heom/test_heom.py | .py | """
Tests for qutip.solver.heom.
"""
from qutip.solver.heom import (
BathExponent,
Bath,
BosonicBath,
DrudeLorentzBath,
DrudeLorentzPadeBath,
UnderDampedBath,
FermionicBath,
LorentzianBath,
LorentzianPadeBath,
heomsolve,
HEOMSolver,
HEOMResult,
HSolverDL,
Hierarc... | 46 | 1,006 |
qutip | qutip/tests/solver/heom/test_bofin_baths.py | .py | """
Tests for qutip.solver.heom.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,
UnderDampedB... | 467 | 15,913 |
qutip | qutip/tests/solver/cy/test_nm_mcsolve.py | .py | 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... | 162 | 4,827 |
qutip | qutip/tests/core/test_superop_reps.py | .py | """
Created on Wed May 29 11:23:46 2013
@author: dcriger
"""
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,
kraus_to_super, to_super, to_superpauli, superpauli_to_super, t... | 397 | 13,987 |
qutip | qutip/tests/core/test_brtools.py | .py | 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, brcrossterm
from qutip.core._brtensor import (
_br_term_dense, _br_term_sparse, _br_term_data,
_br_cterm_dense, _br_cterm_sparse... | 414 | 14,166 |
qutip | qutip/tests/core/test_metrics.py | .py | 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.dimensions import Space
from qutip.c... | 570 | 21,299 |
qutip | qutip/tests/core/test_qobj.py | .py | 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
from qutip.core.dimensions import flatten
@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
def datatype(request):
return request.param
... | 1,533 | 48,183 |
qutip | qutip/tests/core/test_superoper.py | .py | import numpy as np
import scipy.linalg
import qutip
from qutip.core import data as _data
import pytest
def f(t):
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:
... | 284 | 10,245 |
qutip | qutip/tests/core/test_expect.py | .py | 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... | 176 | 7,547 |
qutip | qutip/tests/core/test_coefficient.py | .py | 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, const,
CompilationOptions, Coefficient,
clean_compiled_coeffic... | 501 | 16,460 |
qutip | qutip/tests/core/test_tensor.py | .py | 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, enr_fock
)
d... | 279 | 10,738 |
qutip | qutip/tests/core/test_qobjevo.py | .py | import operator
import pytest
from qutip import (
Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz, num, destroy, rand_stochastic,
rand_herm, rand_ket, liouvillian, basis, spre, spost, to_choi, expect,
rand_ket, rand_dm, operator_to_vector, SESolver, MESolver, CoreOptions
)
import qutip.core.data as _data
... | 717 | 23,197 |
qutip | qutip/tests/core/test_local_matmul.py | .py | import pytest
import numpy as np
from qutip import (
rand_ket, rand_dm,
Qobj, local_matmul, expand_operator,
tensor, sigmax, destroy, gates, sprepost, qeye,
)
def test_single_qubit_gate_on_ket():
state = rand_ket([2, 2, 2])
op = sigmax()
extended_op = tensor(qeye(2), sigmax(), qeye(2))
e... | 328 | 9,278 |
qutip | qutip/tests/core/test_operators.py | .py | 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... | 439 | 15,399 |
qutip | qutip/tests/core/test_dimensions.py | .py | import numbers
from typing import Literal
import pytest
import collections
import numpy as np
import qutip
from qutip.core.dimensions import (
flatten, unflatten, enumerate_flat, deep_remove, deep_map,
dims_idxs_to_tensor_idxs, dims_to_tensor_shape, dims_to_tensor_perm,
einsum, to_tensor_rep, from_tensor_re... | 484 | 19,456 |
qutip | qutip/tests/core/test_direct_sum.py | .py | import pytest
from qutip import (
Qobj, QobjEvo,
basis, fock_dm, qzero, qzero_like, sigmax, sigmay, spre,
operator_to_vector, vector_to_operator
)
from qutip.core.dimensions import Dimensions, SumSpace
from qutip.core.direct_sum import (
direct_sum, direct_sum_sparse, direct_component, set_direct_comp... | 379 | 14,783 |
qutip | qutip/tests/core/test_eigen.py | .py | 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="s... | 125 | 4,433 |
qutip | qutip/tests/core/test_environment.py | .py | import pytest
from importlib.util import find_spec
from numbers import Number
import numpy as np
from scipy.integrate import quad_vec
from qutip.utilities import n_thermal
from qutip.core.environment import (
BosonicEnvironment,
DrudeLorentzEnvironment,
UnderDampedEnvironment,
OhmicEnvironment,
C... | 1,528 | 56,398 |
qutip | qutip/tests/core/test_eigenstates.py | .py | 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 gaug... | 102 | 4,411 |
qutip | qutip/tests/core/test_states.py | .py | 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 ... | 341 | 12,007 |
qutip | qutip/tests/core/test_ptrace.py | .py | 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=in... | 152 | 5,216 |
qutip | qutip/tests/core/test_options.py | .py | import pytest
import numpy
import qutip
from qutip.core.numpy_backend import np
from qutip import CoreOptions, settings
# Mocking JAX to demonstrate backend switching
class Mock_JAX:
def sum(*a, **kw):
return "jax_sum"
def __getattr__(self, _):
return "other"
mock_jax = Mock_JAX()
mock_np ... | 90 | 3,193 |
qutip | qutip/tests/core/test_gates.py | .py | import pytest
import numpy as np
import qutip
from qutip.core import gates
from qutip import Qobj
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,
w... | 213 | 9,006 |
qutip | qutip/tests/core/test_energy_restricted.py | .py | import pytest
import itertools
import random
import numpy as np
import qutip
import scipy.sparse
from qutip.core.dimensions import flatten
from qutip.core.energy_restricted import EnrSpace, Space
def _n_enr_states(dimensions, n_excitations):
"""
Calculate the total number of distinct ENR states for a given s... | 384 | 13,752 |
qutip | qutip/tests/core/data/test_expect.py | .py | """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, Dia
from itertools import product
class TestExpect(Binary... | 74 | 2,616 |
qutip | qutip/tests/core/data/test_csr.py | .py | 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 = ['in... | 418 | 17,017 |
qutip | qutip/tests/core/data/test_scipy_sparse.py | .py | """
Tests for qutip.core.data._scipy_sparse, in particular the forward-compatible
"removal path": the behaviour once a future SciPy stops shipping the legacy
``csr_matrix`` / ``dia_matrix`` types.
qutip stores everything internally as the modern ``*_array`` types, so the only
place that needs the legacy matrices is th... | 136 | 5,187 |
qutip | qutip/tests/core/data/test_operators.py | .py | 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,... | 81 | 2,640 |
qutip | qutip/tests/core/data/test_dense.py | .py | 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'),
... | 327 | 13,437 |
qutip | qutip/tests/core/data/test_dia.py | .py | import numpy as np
import scipy.sparse
import pytest
from qutip.core import data, qeye, CoreOptions
from qutip.core.data import dia, 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',... | 367 | 14,663 |
qutip | qutip/tests/core/data/test_linalg.py | .py | import qutip.settings as settings
import numpy as np
import scipy
import pytest
import qutip
import warnings
from qutip.core import data as _data
from qutip.core.data import Data, Dense, CSR, Dia
skip_no_mkl = pytest.mark.skipif(
not settings.has_mkl, reason="mkl not available"
)
class TestSolve():
def op_... | 158 | 5,238 |
qutip | qutip/tests/core/data/test_target_mode_matmul.py | .py | import pytest
import numpy as np
from qutip.core.data import target_mode_matmul
from qutip import (
rand_ket, rand_dm,
Qobj, local_matmul, expand_operator,
tensor, sigmax, destroy, gates, sprepost, qeye,
)
@pytest.mark.parametrize("dtype", ["csr", "dense", "dia"])
@pytest.mark.parametrize("trans", [True... | 49 | 1,444 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.