Fix circular imports

Author: marvinpfoertner

src/probnum/__init__.py

@@ -24,19 +24,19 @@
     LambdaStoppingCriterion,
 )
 
-# isort: on
-
+# Supporting packages need to be imported before compat
 from . import (
-    diffeq,
-    filtsmooth,
-    linalg,
     linops,
-    problems,
-    quad,
     randprocs,
     randvars,
-    utils,
 )
+
+# Compatibility functionality between backend, linops and randvars
+from . import compat
+
+# isort: on
+
+from . import diffeq, filtsmooth, linalg, problems, quad, utils
 from ._version import version as __version__
 from .randvars import asrandvar
 

src/probnum/backend/_core/__init__.py

@@ -111,6 +111,7 @@ def as_scalar(x: ScalarArgType, dtype: DTypeArgType = None) -> ArrayType:
     "cast",
     "promote_types",
     "is_floating",
+    "is_floating_dtype",
     "finfo",
     # Shape Arithmetic
     "reshape",

src/probnum/compat/_core.py

@@ -1,8 +1,9 @@
 from typing import Tuple, Union
 
 import numpy as np
+import scipy.sparse
 
-from probnum import backend, linops
+from probnum import backend, linops, randvars
 
 __all__ = [
     "to_numpy",
@@ -34,3 +35,60 @@ def cast(a, dtype=None, casting="unsafe", copy=None):
         return a.astype(dtype=dtype, casting=casting, copy=copy)
 
     return backend.cast(a, dtype=dtype, casting=casting, copy=copy)
+
+
+def atleast_1d(
+    *objs: Union[
+        backend.ndarray,
+        linops.LinearOperator,
+        randvars.RandomVariable,
+    ]
+) -> Union[
+    Union[
+        backend.ndarray,
+        linops.LinearOperator,
+        randvars.RandomVariable,
+    ],
+    Tuple[
+        Union[
+            backend.ndarray,
+            linops.LinearOperator,
+            randvars.RandomVariable,
+        ],
+        ...,
+    ],
+]:
+    """Reshape arrays, linear operators and random variables to have at least 1
+    dimension.
+
+    Scalar inputs are converted to 1-dimensional arrays, whilst
+    higher-dimensional inputs are preserved.
+
+    Parameters
+    ----------
+    objs:
+        One or more input linear operators, random variables or arrays.
+
+    Returns
+    -------
+    res :
+        An array / random variable / linop or tuple of arrays / random variables /
+        linear operators, each with ``a.ndim >= 1``.
+    """
+    res = []
+
+    for obj in objs:
+        if isinstance(obj, np.ndarray):
+            obj = np.atleast_1d(obj)
+        elif isinstance(obj, backend.ndarray):
+            obj = backend.atleast_1d(obj)
+        elif isinstance(obj, randvars.RandomVariable):
+            if obj.ndim == 0:
+                obj = obj.reshape((1,))
+
+        res.append(obj)
+
+    if len(res) == 1:
+        return res[0]
+
+    return tuple(res)

src/probnum/linalg/_problinsolve.py

@@ -13,7 +13,7 @@
 import scipy.sparse
 
 import probnum  # pylint: disable=unused-import
-from probnum import linops, randvars, utils
+from probnum import linops, randvars
 from probnum.linalg.solvers.matrixbased import SymmetricMatrixBasedSolver
 from probnum.typing import LinearOperatorArgType
 
@@ -199,7 +199,7 @@ def problinsolve(
             # Select and initialize solver
             linear_solver = _init_solver(
                 A=A,
-                b=utils.as_colvec(b[:, i]),
+                b=as_colvec(b[:, i]),
                 A0=A0,
                 Ainv0=Ainv0,
                 x0=x,
@@ -342,9 +342,9 @@ def _preprocess_linear_system(A, b, x0=None):
     """
     # Transform linear system to correct dimensions
     if not isinstance(b, randvars.RandomVariable):
-        b = utils.as_colvec(b)  # (n,) -> (n, 1)
+        b = as_colvec(b)  # (n,) -> (n, 1)
     if x0 is not None:
-        x0 = utils.as_colvec(x0)  # (n,) -> (n, 1)
+        x0 = as_colvec(x0)  # (n,) -> (n, 1)
 
     return A, b, x0
 
@@ -475,3 +475,24 @@ def _postprocess(info, A):
             scipy.linalg.LinAlgWarning,
             stacklevel=3,
         )
+
+
+def as_colvec(
+    vec: Union[np.ndarray, "probnum.randvars.RandomVariable"]
+) -> Union[np.ndarray, "probnum.randvars.RandomVariable"]:
+    """Transform the given vector or random variable to column format. Given a vector
+    (or random variable) of dimension (n,) return an array with dimensions (n, 1)
+    instead. Higher-dimensional arrays are not changed.
+
+    Parameters
+    ----------
+    vec
+        Vector, array or random variable to be transformed into a column vector.
+    """
+    if isinstance(vec, probnum.randvars.RandomVariable):
+        if vec.shape != (vec.shape[0], 1):
+            vec.reshape(newshape=(vec.shape[0], 1))
+    else:
+        if vec.ndim == 1:
+            return vec[:, None]
+    return vec

src/probnum/randvars/_normal.py

@@ -4,7 +4,7 @@
 import operator
 from typing import Optional, Union
 
-from probnum import backend, compat, config, linops
+from probnum import backend, config, linops
 from probnum.typing import (
     ArrayLike,
     ArrayLikeGetitemArgType,
@@ -82,6 +82,9 @@ def __init__(
         if not backend.is_floating_dtype(dtype):
             dtype = backend.double
 
+        # Circular dependency -> defer import
+        from probnum import compat  # pylint: disable=import-outside-toplevel
+
         mean = compat.cast(mean, dtype=dtype, casting="safe", copy=False)
         cov = compat.cast(cov, dtype=dtype, casting="safe", copy=False)
 

src/probnum/utils/__init__.py

@@ -1,12 +1,9 @@
 """Utility Functions."""
 
 from .argutils import *
-from .arrayutils import *
 
 # Public classes and functions. Order is reflected in documentation.
 __all__ = [
-    "as_colvec",
-    "atleast_1d",
     "as_numpy_scalar",
     "as_shape",
 ]