Merge pull request #2358 from pmenczel/typos

Fixed a few typos

qutip/simdiag.py

@@ -79,15 +79,15 @@ def simdiag(ops, evals: bool = True, *,
         A = ops[jj]
         shape = A.shape
         if shape[0] != shape[1]:
-            raise TypeError('Matricies must be square.')
+            raise TypeError('Matrices 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')
+            raise TypeError('Matrices 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.')
+                raise TypeError('Matrices must commute.')
 
     # TODO: rewrite using Data object
     eigvals, eigvecs = _data.eigs(ops[0].data, True, True)

qutip/solver/_feedback.py

@@ -133,18 +133,18 @@ def __repr__(self):
         return "CollapseFeedback"
 
 
-def _default_weiner(t):
+def _default_wiener(t):
     return np.zeros(1)
 
 
-class _WeinerFeedback(_Feedback):
-    code = "WeinerFeedback"
+class _WienerFeedback(_Feedback):
+    code = "WienerFeedback"
 
     def __init__(self, default=None):
-        self.default = default or _default_weiner
+        self.default = default or _default_wiener
 
     def check_consistency(self, dims):
         pass
 
     def __repr__(self):
-        return "WeinerFeedback"
+        return "WienerFeedback"

qutip/solver/nonmarkov/transfertensor.py

@@ -71,7 +71,7 @@ def ttmsolve(dynmaps, state0, times, e_ops=(), num_learning=0, options=None):
     opt = {
         "store_final_state": False,
         "store_states": None,
-        "normalize_output": "ket",
+        "normalize_output": True,
         "threshold": 0.0,
         "num_learning": 0,
     }

qutip/solver/result.py

@@ -526,7 +526,7 @@ def __init__(
         self._post_init(**kw)
 
     @property
-    def _store_average_density_matricies(self) -> bool:
+    def _store_average_density_matrices(self) -> bool:
         return (
             self.options["store_states"]
             or (self.options["store_states"] is None and self._raw_ops == {})
@@ -536,7 +536,7 @@ def _store_average_density_matricies(self) -> bool:
     def _store_final_density_matrix(self) -> bool:
         return (
             self.options["store_final_state"]
-            and not self._store_average_density_matricies
+            and not self._store_average_density_matrices
             and not self.options["keep_runs_results"]
         )
 
@@ -552,7 +552,7 @@ def _add_first_traj(self, trajectory):
         """
         self.times = trajectory.times
 
-        if trajectory.states and self._store_average_density_matricies:
+        if trajectory.states and self._store_average_density_matrices:
             self._sum_states = [
                 qzero_like(self._to_dm(state)) for state in trajectory.states
             ]
@@ -668,7 +668,7 @@ def _post_init(self):
         store_trajectory = self.options["keep_runs_results"]
         if store_trajectory:
             self.add_processor(self._store_trajectory)
-        if self._store_average_density_matricies:
+        if self._store_average_density_matrices:
             self.add_processor(self._reduce_states)
         if self._store_final_density_matrix:
             self.add_processor(self._reduce_final_state)
@@ -1131,7 +1131,7 @@ def _average_computer(self):
 
     def _add_first_traj(self, trajectory):
         super()._add_first_traj(trajectory)
-        if trajectory.states and self._store_average_density_matricies:
+        if trajectory.states and self._store_average_density_matrices:
             del self._sum_states
             self._sum_states_no_jump = [
                 qzero_like(self._to_dm(state)) for state in trajectory.states

qutip/solver/solver_base.py

@@ -38,7 +38,7 @@ class Solver:
         "progress_kwargs": {"chunk_size": 10},
         "store_final_state": False,
         "store_states": None,
-        "normalize_output": "ket",
+        "normalize_output": True,
         "method": "adams",
     }
     _resultclass = Result

qutip/solver/stochastic.py

@@ -8,7 +8,7 @@
 import numpy as np
 from functools import partial
 from .solver_base import _solver_deprecation
-from ._feedback import _QobjFeedback, _DataFeedback, _WeinerFeedback
+from ._feedback import _QobjFeedback, _DataFeedback, _WienerFeedback
 
 
 class StochasticTrajResult(Result):
@@ -232,14 +232,14 @@ def arguments(self, args):
             sc_op.arguments(args)
 
     def _register_feedback(self, val):
-        self.H._register_feedback({"wiener_process": val}, "stochatic solver")
+        self.H._register_feedback({"wiener_process": val}, "stochastic solver")
         for c_op in self.c_ops:
             c_op._register_feedback(
-                {"WeinerFeedback": val}, "stochatic solver"
+                {"WienerFeedback": val}, "stochastic solver"
             )
         for sc_op in self.sc_ops:
             sc_op._register_feedback(
-                {"WeinerFeedback": val}, "stochatic solver"
+                {"WienerFeedback": val}, "stochastic solver"
             )
 
 
@@ -713,13 +713,13 @@ def options(self, new_options):
         MultiTrajSolver.options.fset(self, new_options)
 
     @classmethod
-    def WeinerFeedback(cls, default=None):
+    def WienerFeedback(cls, default=None):
         """
-        Weiner function of the trajectory argument for time dependent systems.
+        Wiener function of the trajectory argument for time dependent systems.
 
         When used as an args:
 
-            ``QobjEvo([op, func], args={"W": SMESolver.WeinerFeedback()})``
+            ``QobjEvo([op, func], args={"W": SMESolver.WienerFeedback()})``
 
         The ``func`` will receive a function as ``W`` that return an array of
         wiener processes values at ``t``. The wiener process for the i-th
@@ -729,7 +729,7 @@ def WeinerFeedback(cls, default=None):
 
         .. note::
 
-            WeinerFeedback can't be added to a running solver when updating
+            WienerFeedback can't be added to a running solver when updating
             arguments between steps: ``solver.step(..., args={})``.
 
         Parameters
@@ -739,7 +739,7 @@ def WeinerFeedback(cls, default=None):
             When not passed, a function returning ``np.array([0])`` is used.
 
         """
-        return _WeinerFeedback(default)
+        return _WienerFeedback(default)
 
     @classmethod
     def StateFeedback(cls, default=None, raw_data=False):

qutip/tests/solver/test_stochastic.py

@@ -334,7 +334,7 @@ def func(t, A, W):
         [destroy(N), func],
         args={
             "A": SMESolver.ExpectFeedback(num(10)),
-            "W": SMESolver.WeinerFeedback()
+            "W": SMESolver.WienerFeedback()
         }
     )]
     psi0 = basis(N, N-3)