mumpy-toolkit 0.2.0__py3-none-any.whl

mumpy/__init__.py

@@ -0,0 +1,128 @@
+"""mumpy — drop-in numpy-compatible library + data-science / ML / DL toolkit.
+
+Same API as numpy for the common 95%:
+    import mumpy as cp
+    a = cp.arange(10_000_000)
+    b = cp.sqrt(a)          # multithreaded for large arrays
+    c = cp.fma(a, b, 1.0)   # fused a*b+c, single pass
+
+Beyond numpy — one import for the whole workflow:
+    cp.io / cp.db / cp.frame      # IO, databases (sqlite/postgres/duckdb), DataFrame
+    cp.stats / cp.preprocessing   # EDA, scalers, encoders, imputers
+    cp.metrics / cp.ml            # metrics + classic ML (sklearn-like API)
+    cp.nn / cp.viz / cp.utils     # tiny deep learning + one-line plots
+
+Speed sources (no C compiler needed):
+1. chunked ThreadPool for compute-bound element-wise ufuncs,
+2. fused multiply-add fma/fms/fnma/lerp with half peak memory,
+3. scipy.fft with workers=-1 when available,
+4. einsum(optimize=True), contiguous-layout matmul.
+"""
+from __future__ import annotations
+
+import numpy as _np
+
+from ._core import (
+    ndarray, array, asarray, asanyarray, ascontiguousarray, asnumpy, copy,
+    zeros, ones, empty, full, zeros_like, ones_like, empty_like, full_like,
+    arange, linspace, logspace, eye, identity, diag,
+    reshape, ravel, transpose, concatenate, stack, vstack, hstack,
+    split, tile, repeat,
+)
+from ._math import (
+    add, subtract, multiply, divide, power, sqrt, exp, log,
+    sin, cos, tan, abs, absolute, clip, where, fma, fms, fnma, lerp,
+    hypot, maximum, minimum, expm1, log1p, log2, log10, square, cbrt,
+    reciprocal, arcsin, arccos, arctan, arctan2, sinh, cosh, tanh,
+    floor, ceil, rint, sign, sinc,
+    sum, mean, min, max, amin, amax, prod, std, var,
+    nansum, nanmean, nanmin, nanmax, nanstd,
+    any, all, cumsum, cumprod, dot, matmul, einsum, tensordot,
+    vdot, inner, outer, kron, trace, sort, argsort,
+)
+from . import linalg, fft, random, io, db, frame, stats, preprocessing, metrics, ml, nn, utils
+try:
+    from . import viz  # optional matplotlib
+except Exception:
+    viz = None  # type: ignore
+from ._parallel import MAX_WORKERS, PARALLEL_THRESHOLD, get_workers
+
+__version__ = "0.2.0"
+
+# ---- numpy compat: re-export everything else verbatim ----
+_COMPAT = [
+    "pi", "e", "inf", "nan", "newaxis",
+    "float16", "float32", "float64", "int8", "int16", "int32", "int64",
+    "uint8", "uint16", "uint32", "uint64", "bool_", "complex64", "complex128",
+    "ndim", "shape", "size", "dtype", "result_type", "broadcast_arrays",
+    "broadcast_to", "expand_dims", "squeeze", "flatten", "moveaxis",
+    "swapaxes", "flip", "roll", "rot90", "pad", "meshgrid",
+    "unique", "intersect1d", "union1d", "setdiff1d", "isin", "in1d",
+    "take", "put", "compress", "extract", "argmax", "argmin", "nonzero",
+    "count_nonzero", "flatnonzero", "argwhere", "searchsorted", "digitize",
+    "histogram", "bincount", "corrcoef", "cov", "polyfit", "polyval",
+    "convolve", "gradient", "diff", "ediff1d", "interp", "percentile",
+    "quantile", "median", "average", "ptp", "allclose", "isclose",
+    "array_equal", "array_equiv", "isnan", "isinf", "isfinite",
+    "nan_to_num", "nansum", "nanmean", "nanmin", "nanmax",
+    "logical_and", "logical_or", "logical_not", "logical_xor",
+    "greater", "greater_equal", "less", "less_equal", "equal", "not_equal",
+    "fmax", "fmin",
+    "arctan2",
+    "round", "fix", "trunc",
+    "real", "imag", "conj", "conjugate", "angle",
+    "degrees", "radians", "mod", "remainder", "divmod", "fmod",
+    "bitwise_and", "bitwise_or", "bitwise_xor", "invert", "left_shift", "right_shift",
+    "vecdot",
+]
+for _name in _COMPAT:
+    if hasattr(_np, _name) and _name not in globals():
+        globals()[_name] = getattr(_np, _name)
+
+__all__ = [
+    "ndarray", "array", "asarray", "asanyarray", "ascontiguousarray", "asnumpy", "copy",
+    "zeros", "ones", "empty", "full", "zeros_like", "ones_like", "empty_like", "full_like",
+    "arange", "linspace", "logspace", "eye", "identity", "diag",
+    "reshape", "ravel", "transpose", "concatenate", "stack", "vstack", "hstack",
+    "split", "tile", "repeat",
+    "add", "subtract", "multiply", "divide", "power", "sqrt", "exp", "log",
+    "sin", "cos", "tan", "abs", "absolute", "clip", "where", "fma", "fms", "fnma", "lerp",
+    "hypot", "maximum", "minimum", "expm1", "log1p", "log2", "log10", "square", "cbrt",
+    "reciprocal", "arcsin", "arccos", "arctan", "arctan2", "sinh", "cosh", "tanh",
+    "floor", "ceil", "rint", "sign", "sinc",
+    "sum", "mean", "min", "max", "amin", "amax", "prod", "std", "var",
+    "nansum", "nanmean", "nanmin", "nanmax", "nanstd",
+    "any", "all", "cumsum", "cumprod", "dot", "matmul", "einsum", "tensordot",
+    "vdot", "inner", "outer", "kron", "trace", "sort", "argsort",
+    "linalg", "fft", "random", "io", "db", "frame", "stats", "preprocessing",
+    "metrics", "ml", "nn", "utils", "viz",
+    "MAX_WORKERS", "PARALLEL_THRESHOLD",
+    "__version__",
+]
+
+
+def info():
+    import os
+    return {
+        "version": __version__,
+        "numpy": _np.__version__,
+        "workers": MAX_WORKERS,
+        "cpus": os.cpu_count(),
+        "parallel_threshold": PARALLEL_THRESHOLD,
+        "scipy_fft": fft.has_scipy(),
+        "modules": ["io", "db", "frame", "stats", "preprocessing",
+                    "metrics", "ml", "nn", "utils", "viz"],
+    }
+
+
+def set_workers(n: int):
+    """Tune parallelism. set_workers(1) == pure-numpy behavior."""
+    from . import _parallel
+    _parallel.MAX_WORKERS = max(1, int(n))
+    globals()["MAX_WORKERS"] = _parallel.MAX_WORKERS
+
+
+def set_threshold(n: int):
+    from . import _parallel
+    _parallel.PARALLEL_THRESHOLD = int(n)
+    globals()["PARALLEL_THRESHOLD"] = int(n)

mumpy/_core.py

@@ -0,0 +1,218 @@
+"""mumpy core: numpy-compatible ndarray + creation routines."""
+from __future__ import annotations
+
+import builtins
+import numpy as np
+builtins_max = builtins.max
+
+__all__ = [
+    "ndarray", "array", "asarray", "asanyarray", "ascontiguousarray",
+    "zeros", "ones", "empty", "full", "zeros_like", "ones_like", "empty_like",
+    "full_like", "arange", "linspace", "logspace", "eye", "identity", "diag",
+    "reshape", "ravel", "transpose", "concatenate", "stack", "vstack", "hstack",
+    "split", "tile", "repeat", "copy", "asnumpy",
+]
+
+
+class ndarray(np.ndarray):
+    """mumpy array: subclasses np.ndarray so every numpy API accepts it.
+
+    Adds convenience fused/fast methods that avoid temporaries.
+    """
+
+    def __new__(cls, *args, **kwargs):
+        obj = np.asarray(*args, **kwargs).view(cls)
+        return obj
+
+    def __array_finalize__(self, obj):
+        pass
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        # Route large element-wise ops through the parallel engine so that
+        # BOTH `cp.sqrt(a)` and plain `a / N`, `a * b + c` syntax are faster.
+        import numpy as _np
+        try:
+            from ._parallel import parallel_ewise, PARALLEL_THRESHOLD
+            _PARALLEL_UFUNCS = frozenset({
+                "add", "subtract", "multiply", "divide", "true_divide",
+                "power", "sqrt", "exp", "log", "sin", "cos", "tan",
+                "absolute", "maximum", "minimum",
+            })
+            if method == "__call__" and ufunc.__name__ in _PARALLEL_UFUNCS:
+                if kwargs.get("where", None) is None and kwargs.get("casting", None) is None:
+                    arrs = [x for x in inputs if isinstance(x, _np.ndarray)]
+                    size = builtins_max([x.size for x in arrs], default=0) if arrs else 0
+                    if size >= PARALLEL_THRESHOLD:
+                        out = kwargs.pop("out", None)
+                        o = out[0] if isinstance(out, tuple) and len(out) == 1 else out
+
+                        def _f(*views, out=None):
+                            ufunc(*views, out=out)
+                        r = parallel_ewise(_f, *inputs, out=o)
+                        if o is not None:
+                            return o
+                        return r.view(ndarray) if isinstance(r, _np.ndarray) else r
+        except Exception:
+            pass
+        # default path: unwrap to plain ndarray and call the ufunc
+        # (calling super().__array_ufunc__ returns NotImplemented on numpy>=2)
+        def _plain(x):
+            if isinstance(x, ndarray):
+                return x.view(_np.ndarray)
+            if isinstance(x, _np.ndarray):
+                return x.view(_np.ndarray)
+            return x
+        inputs = tuple(_plain(x) for x in inputs)
+        if "out" in kwargs and kwargs["out"] is not None:
+            out = kwargs["out"]
+            kwargs["out"] = tuple(_plain(o) if o is not None else None for o in out)
+        result = getattr(ufunc, method)(*inputs, **kwargs)
+        return _wrap(result) if isinstance(result, _np.ndarray) else result
+
+    # -- fast methods (avoid extra temporaries) --
+    def fma(self, b, c):
+        """self * b + c in one pass (no intermediate)."""
+        from ._math import fma
+        return fma(self, b, c)
+
+    def squared(self):
+        return np.multiply(self, self)
+
+    def asum(self):
+        return np.abs(np.asanyarray(self)).sum()
+
+    def to_numpy(self):
+        return np.asanyarray(self).view(np.ndarray)
+
+
+def _wrap(x):
+    if isinstance(x, np.ndarray) and not isinstance(x, ndarray):
+        return x.view(ndarray)
+    return x
+
+
+def array(obj, dtype=None, copy=True, order="K", subok=False, ndmin=0, **kw):
+    return _wrap(np.array(obj, dtype=dtype, copy=copy, order=order,
+                          subok=subok, ndmin=ndmin, **kw))
+
+
+def asarray(a, dtype=None, order=None):
+    return _wrap(np.asarray(a, dtype=dtype, order=order))
+
+
+def asanyarray(a, dtype=None, order=None):
+    return _wrap(np.asanyarray(a, dtype=dtype, order=order))
+
+
+def ascontiguousarray(a, dtype=None):
+    return _wrap(np.ascontiguousarray(a, dtype=dtype))
+
+
+def asnumpy(a):
+    """Unwrap to plain np.ndarray (zero-copy view)."""
+    return np.asanyarray(a).view(np.ndarray)
+
+
+def copy(a, order="K"):
+    return _wrap(np.array(a, copy=True, order=order, subok=True))
+
+
+def zeros(shape, dtype=float, order="C"):
+    return _wrap(np.zeros(shape, dtype=dtype, order=order))
+
+
+def ones(shape, dtype=float, order="C"):
+    return _wrap(np.ones(shape, dtype=dtype, order=order))
+
+
+def empty(shape, dtype=float, order="C"):
+    return _wrap(np.empty(shape, dtype=dtype, order=order))
+
+
+def full(shape, fill_value, dtype=None, order="C"):
+    return _wrap(np.full(shape, fill_value, dtype=dtype, order=order))
+
+
+def zeros_like(a, dtype=None, order="K", subok=False, shape=None):
+    return _wrap(np.zeros_like(a, dtype=dtype, order=order, subok=True, shape=shape))
+
+
+def ones_like(a, dtype=None, order="K", subok=False, shape=None):
+    return _wrap(np.ones_like(a, dtype=dtype, order=order, subok=True, shape=shape))
+
+
+def empty_like(a, dtype=None, order="K", subok=False, shape=None):
+    return _wrap(np.empty_like(a, dtype=dtype, order=order, subok=True, shape=shape))
+
+
+def full_like(a, fill_value, dtype=None, order="K", subok=False, shape=None):
+    return _wrap(np.full_like(a, fill_value, dtype=dtype, order=order, subok=True, shape=shape))
+
+
+def arange(*args, **kwargs):
+    return _wrap(np.arange(*args, **kwargs))
+
+
+def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0):
+    r = np.linspace(start, stop, num=num, endpoint=endpoint,
+                    retstep=retstep, dtype=dtype, axis=axis)
+    if retstep:
+        return _wrap(r[0]), r[1]
+    return _wrap(r)
+
+
+def logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0):
+    return _wrap(np.logspace(start, stop, num=num, endpoint=endpoint,
+                             base=base, dtype=dtype, axis=axis))
+
+
+def eye(N, M=None, k=0, dtype=float, order="C"):
+    return _wrap(np.eye(N, M=M, k=k, dtype=dtype, order=order))
+
+
+def identity(n, dtype=float):
+    return _wrap(np.identity(n, dtype=dtype))
+
+
+def diag(v, k=0):
+    return _wrap(np.diag(v, k=k))
+
+
+def reshape(a, shape, order="C"):
+    return _wrap(np.reshape(a, shape, order=order))
+
+
+def ravel(a, order="C"):
+    return _wrap(np.ravel(a, order=order))
+
+
+def transpose(a, axes=None):
+    return _wrap(np.transpose(a, axes=axes))
+
+
+def concatenate(arrays, axis=0, out=None, dtype=None, casting="same_kind"):
+    return _wrap(np.concatenate(arrays, axis=axis, out=out, dtype=dtype, casting=casting))
+
+
+def stack(arrays, axis=0, out=None, dtype=None, casting="same_kind"):
+    return _wrap(np.stack(arrays, axis=axis, out=out, dtype=dtype, casting=casting))
+
+
+def vstack(tup, dtype=None, casting="same_kind"):
+    return _wrap(np.vstack(tup, dtype=dtype, casting=casting))
+
+
+def hstack(tup, dtype=None, casting="same_kind"):
+    return _wrap(np.hstack(tup, dtype=dtype, casting=casting))
+
+
+def split(ary, indices_or_sections, axis=0):
+    return [_wrap(x) for x in np.split(ary, indices_or_sections, axis=axis)]
+
+
+def tile(A, reps):
+    return _wrap(np.tile(A, reps))
+
+
+def repeat(a, repeats, axis=None):
+    return _wrap(np.repeat(a, repeats, axis=axis))

mumpy/_math.py

@@ -0,0 +1,283 @@
+"""mumpy math: numpy-compatible functions with parallel fast paths + fused ops."""
+from __future__ import annotations
+
+import builtins
+import numpy as np
+from ._parallel import parallel_ewise
+
+__all__ = [
+    "add", "subtract", "multiply", "divide", "power", "sqrt", "exp", "log",
+    "sin", "cos", "tan", "abs", "absolute", "clip", "where", "fma", "fms",
+    "fnma", "lerp", "hypot", "maximum", "minimum",
+    "expm1", "log1p", "log2", "log10", "square", "cbrt", "reciprocal",
+    "arcsin", "arccos", "arctan", "arctan2", "sinh", "cosh", "tanh",
+    "floor", "ceil", "rint", "sign", "sinc",
+    "sum", "mean", "min", "max", "amin", "amax", "prod", "std", "var",
+    "any", "all", "cumsum", "cumprod", "nansum", "nanmean", "nanmin", "nanmax",
+    "nanstd", "dot", "matmul", "einsum", "tensordot",
+    "vdot", "inner", "outer", "kron", "trace", "sort", "argsort",
+]
+
+
+def _ew(numpy_func):
+    def wrapper(*args, out=None, **kw):
+        outs = [np.asanyarray(a).view(np.ndarray) if isinstance(a, np.ndarray) else a
+                for a in args]
+        try:
+            size = builtins.max((np.asanyarray(o).size for o in outs), default=0)
+        except Exception:
+            size = 0
+        from ._parallel import PARALLEL_THRESHOLD
+        from ._core import _wrap
+        if size >= PARALLEL_THRESHOLD and not kw:
+            plains = [np.asanyarray(a).view(np.ndarray) if isinstance(a, np.ndarray) else a
+                      for a in args]
+
+            def _f(*views, out=None):
+                numpy_func(*views, out=out, **kw)
+            try:
+                return _wrap(parallel_ewise(_f, *plains, out=out))
+            except Exception:
+                pass
+        if out is None:
+            r = numpy_func(*[np.asanyarray(a).view(np.ndarray)
+                             if isinstance(a, np.ndarray) else a for a in args], **kw)
+        else:
+            r = numpy_func(*[np.asanyarray(a).view(np.ndarray)
+                             if isinstance(a, np.ndarray) else a for a in args],
+                           out=out, **kw)
+            return out
+        return _wrap(r) if isinstance(r, np.ndarray) else r
+    wrapper.__name__ = getattr(numpy_func, "__name__", "ufunc")
+    wrapper.__doc__ = getattr(numpy_func, "__doc__", "")
+    return wrapper
+
+
+add = _ew(np.add)
+subtract = _ew(np.subtract)
+multiply = _ew(np.multiply)
+divide = _ew(np.divide)
+power = _ew(np.power)
+sqrt = _ew(np.sqrt)
+exp = _ew(np.exp)
+log = _ew(np.log)
+sin = _ew(np.sin)
+cos = _ew(np.cos)
+tan = _ew(np.tan)
+absolute = _ew(np.absolute)
+abs = absolute
+hypot = _ew(np.hypot)
+maximum = _ew(np.maximum)
+minimum = _ew(np.minimum)
+expm1 = _ew(np.expm1)
+log1p = _ew(np.log1p)
+log2 = _ew(np.log2)
+log10 = _ew(np.log10)
+square = _ew(np.square)
+cbrt = _ew(np.cbrt)
+reciprocal = _ew(np.reciprocal)
+arcsin = _ew(np.arcsin)
+arccos = _ew(np.arccos)
+arctan = _ew(np.arctan)
+arctan2 = _ew(np.arctan2)
+sinh = _ew(np.sinh)
+cosh = _ew(np.cosh)
+tanh = _ew(np.tanh)
+floor = _ew(np.floor)
+ceil = _ew(np.ceil)
+rint = _ew(np.rint)
+sign = _ew(np.sign)
+sinc = _ew(np.sinc)
+
+
+def clip(a, a_min, a_max, out=None):
+    a = np.asanyarray(a)
+    if a.size >= 50000:
+        def _f(v, out=None):
+            np.clip(v, a_min, a_max, out=out)
+        from ._core import _wrap as _w
+        try:
+            return _w(parallel_ewise(_f, a, out=out))
+        except Exception:
+            pass
+    return np.clip(a, a_min, a_max, out=out)
+
+
+def where(condition, x=None, y=None):
+    return np.where(np.asanyarray(condition) if not np.isscalar(condition) else condition,
+                    x, y)
+
+
+def _plain(a):
+    a = np.asanyarray(a)
+    return a.view(np.ndarray) if isinstance(a, np.ndarray) else a
+
+
+def fma(a, b, c, out=None):
+    """Fused multiply-add: a*b + c with ONE allocation (half peak memory)."""
+    a, b, c = _plain(a), _plain(b), _plain(c)
+    if out is None:
+        out = np.multiply(a, b)
+        np.add(out, c, out=out)
+        from ._core import _wrap as _w
+        return _w(out)
+    np.multiply(a, b, out=out)
+    np.add(out, c, out=out)
+    return out
+
+
+def fms(a, b, c, out=None):
+    """Fused multiply-subtract: a*b - c."""
+    a, b, c = _plain(a), _plain(b), _plain(c)
+    if out is None:
+        out = np.multiply(a, b)
+        np.subtract(out, c, out=out)
+        from ._core import _wrap as _w
+        return _w(out)
+    np.multiply(a, b, out=out)
+    np.subtract(out, c, out=out)
+    return out
+
+
+def fnma(a, b, c, out=None):
+    """Fused neg-multiply-add: c - a*b."""
+    a, b, c = _plain(a), _plain(b), _plain(c)
+    if out is None:
+        out = np.multiply(a, b)
+        np.subtract(c, out, out=out)
+        from ._core import _wrap as _w
+        return _w(out)
+    np.multiply(a, b, out=out)
+    # need temp-free: out = c - out
+    np.subtract(c, out, out=out)
+    return out
+
+
+def lerp(a, b, t, out=None):
+    """Linear interpolation: a + (b-a)*t  (single-pass fused)."""
+    a, b, t = _plain(a), _plain(b), _plain(t)
+    if out is None:
+        out = np.subtract(b, a)
+        np.multiply(out, t, out=out)
+        np.add(out, a, out=out)
+        from ._core import _wrap as _w
+        return _w(out)
+    np.subtract(b, a, out=out)
+    np.multiply(out, t, out=out)
+    np.add(out, a, out=out)
+    return out
+
+
+# ---- reductions: numpy is already bandwidth-optimal single-threaded ----
+def sum(a, axis=None, dtype=None, out=None, keepdims=False, **kw):
+    return np.sum(_plain(a), axis=axis, dtype=dtype, out=out, keepdims=keepdims, **kw)
+
+
+def mean(a, axis=None, dtype=None, out=None, keepdims=False, **kw):
+    return np.mean(_plain(a), axis=axis, dtype=dtype, out=out, keepdims=keepdims, **kw)
+
+
+def min(a, axis=None, out=None, keepdims=False, **kw):
+    return np.min(_plain(a), axis=axis, out=out, keepdims=keepdims, **kw)
+
+
+def max(a, axis=None, out=None, keepdims=False, **kw):
+    return np.max(_plain(a), axis=axis, out=out, keepdims=keepdims, **kw)
+
+
+amin, amax = min, max
+
+
+def prod(a, axis=None, dtype=None, out=None, keepdims=False, **kw):
+    return np.prod(_plain(a), axis=axis, dtype=dtype, out=out, keepdims=keepdims, **kw)
+
+
+def any(a, axis=None, out=None, keepdims=False, **kw):
+    return np.any(a, axis=axis, out=out, keepdims=keepdims, **kw)
+
+
+def all(a, axis=None, out=None, keepdims=False, **kw):
+    return np.all(a, axis=axis, out=out, keepdims=keepdims, **kw)
+
+
+def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
+    return np.std(a, axis=axis, dtype=dtype, out=out, ddof=ddof, keepdims=keepdims)
+
+
+def var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
+    return np.var(a, axis=axis, dtype=dtype, out=out, ddof=ddof, keepdims=keepdims)
+
+
+def nansum(a, axis=None, dtype=None, out=None, keepdims=False, **kw):
+    return np.nansum(_plain(a), axis=axis, dtype=dtype, out=out, keepdims=keepdims, **kw)
+
+
+def nanmean(a, axis=None, dtype=None, out=None, keepdims=False, **kw):
+    return np.nanmean(_plain(a), axis=axis, dtype=dtype, out=out, keepdims=keepdims, **kw)
+
+
+def nanmin(a, axis=None, out=None, keepdims=False, **kw):
+    return np.nanmin(_plain(a), axis=axis, out=out, keepdims=keepdims, **kw)
+
+
+def nanmax(a, axis=None, out=None, keepdims=False, **kw):
+    return np.nanmax(_plain(a), axis=axis, out=out, keepdims=keepdims, **kw)
+
+
+def nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, **kw):
+    return np.nanstd(_plain(a), axis=axis, dtype=dtype, out=out, ddof=ddof,
+                     keepdims=keepdims, **kw)
+
+
+def cumsum(a, axis=None, dtype=None, out=None):
+    return np.cumsum(a, axis=axis, dtype=dtype, out=out)
+
+
+def cumprod(a, axis=None, dtype=None, out=None):
+    return np.cumprod(a, axis=axis, dtype=dtype, out=out)
+
+
+# ---- linear algebra entry points (BLAS-backed, same speed + optimize=True) ----
+def dot(a, b, out=None):
+    return np.dot(a, b, out=out)
+
+
+def matmul(a, b, out=None):
+    return np.matmul(a, b, out=out)
+
+
+def einsum(*args, **kwargs):
+    kwargs.setdefault("optimize", True)
+    return np.einsum(*args, **kwargs)
+
+
+def tensordot(a, b, axes=2):
+    return np.tensordot(a, b, axes=axes)
+
+
+def vdot(a, b):
+    return np.vdot(a, b)
+
+
+def inner(a, b):
+    return np.inner(a, b)
+
+
+def outer(a, b, out=None):
+    return np.outer(a, b, out=out)
+
+
+def kron(a, b):
+    return np.kron(a, b)
+
+
+def trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None):
+    return np.trace(a, offset=offset, axis1=axis1, axis2=axis2, dtype=dtype, out=out)
+
+
+def sort(a, axis=-1, kind=None, order=None):
+    return np.sort(a, axis=axis, kind=kind, order=order)
+
+
+def argsort(a, axis=-1, kind=None, order=None):
+    return np.argsort(a, axis=axis, kind=kind, order=order)