maten 0.1.0__py3-none-any.whl

maten/__init__.py

@@ -0,0 +1,57 @@
+"""
+maten — Pure Python scientific computing library
+=================================================
+Single import replaces NumPy + Pandas + Matplotlib + TensorFlow.
+
+    import maten as mt
+
+    mt.array(...)          # arrays
+    mt.DataFrame(...)      # dataframes
+    mt.subplots()          # plots
+    mt.Sequential(...)     # neural networks
+"""
+
+__version__ = "0.1.0"
+__author__  = "maten contributors"
+
+# ── core (NumPy replacement) ──────────────────────────────────
+from maten.core.tensor   import Tensor, array, matmul
+from maten.core.creation import (zeros, ones, full, eye, arange, linspace,
+                                  rand, randn, randint, concatenate, stack)
+from maten.core.math_ops import (sqrt, exp, log, log2, log10,
+                                  sin, cos, tan, tanh,
+                                  abs_, ceil, floor,
+                                  sigmoid, relu, leaky_relu,
+                                  clip, softmax, where, unique, sort)
+from maten.core.linalg   import linalg
+
+# ── frame (Pandas replacement) ────────────────────────────────
+from maten.frame.series    import Series
+from maten.frame.dataframe import DataFrame
+from maten.frame.groupby   import GroupBy
+from maten.frame.io        import read_csv, read_json, concat as concat_frames
+
+# ── plot (Matplotlib replacement) ─────────────────────────────
+from maten.plot.figure import (Figure, Axes,
+                                figure, subplots, show, savefig,
+                                plot, scatter, bar, barh, hist,
+                                fill_between, axhline, axvline,
+                                xlabel, ylabel, title, legend, xlim, ylim)
+from maten.plot.charts import pie, heatmap
+
+# ── neural (TensorFlow replacement) ───────────────────────────
+from maten.neural.autograd   import Value
+from maten.neural.sequential import Module, Sequential
+from maten.neural.layers     import (Parameter, Linear,
+                                     ReLU, Sigmoid, Tanh, Softmax,
+                                     LeakyReLU, Dropout, BatchNorm1d, Flatten)
+from maten.neural.losses     import (MSELoss, MAELoss, BCELoss,
+                                     CrossEntropyLoss, HuberLoss)
+from maten.neural.optimizers import SGD, Adam, AdamW, RMSProp, Adagrad
+from maten.neural.metrics    import (accuracy, mean_squared_error,
+                                     mean_absolute_error, r2_score, rmse,
+                                     precision, recall, f1_score, confusion_matrix)
+from maten.neural.dataloader import DataLoader, Trainer
+
+# ── neural tensor (separate namespace to avoid clash with core) 
+from maten.neural import tensor as nn_tensor

maten/core/creation.py

@@ -0,0 +1,68 @@
+"""
+maten.core.creation — array creation functions
+"""
+
+import random
+from functools import reduce
+import operator
+from maten.core.tensor import Tensor
+
+
+def zeros(shape, dtype=float):
+    if isinstance(shape, int): shape = (shape,)
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([dtype(0)] * size, shape, dtype)
+
+def ones(shape, dtype=float):
+    if isinstance(shape, int): shape = (shape,)
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([dtype(1)] * size, shape, dtype)
+
+def full(shape, fill_value, dtype=float):
+    if isinstance(shape, int): shape = (shape,)
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([dtype(fill_value)] * size, shape, dtype)
+
+def eye(n, dtype=float):
+    t = zeros((n, n), dtype=dtype)
+    for i in range(n):
+        t._data[i * n + i] = dtype(1)
+    return t
+
+def arange(start, stop=None, step=1, dtype=float):
+    if stop is None: start, stop = 0, start
+    data, v = [], start
+    while (step > 0 and v < stop) or (step < 0 and v > stop):
+        data.append(dtype(v)); v += step
+    return Tensor._make(data, (len(data),), dtype)
+
+def linspace(start, stop, num=50, dtype=float):
+    if num == 1:
+        return Tensor._make([dtype(start)], (1,), dtype)
+    step = (stop - start) / (num - 1)
+    data = [dtype(start + i * step) for i in range(num)]
+    return Tensor._make(data, (num,), dtype)
+
+def rand(*shape):
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([random.random() for _ in range(size)], shape, float)
+
+def randn(*shape):
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([random.gauss(0, 1) for _ in range(size)], shape, float)
+
+def randint(low, high, shape):
+    if isinstance(shape, int): shape = (shape,)
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([float(random.randint(low, high - 1)) for _ in range(size)], shape, float)
+
+def concatenate(tensors, axis=0):
+    if axis == 0:
+        data     = []
+        for t in tensors: data.extend(t._data)
+        new_shape = (sum(t._shape[0] for t in tensors),) + tensors[0]._shape[1:]
+        return Tensor._make(data, new_shape, tensors[0].dtype)
+    raise NotImplementedError("concatenate on axis != 0 coming soon")
+
+def stack(tensors, axis=0):
+    return concatenate([t.expand_dims(axis) for t in tensors], axis=axis)

maten/core/linalg.py

@@ -0,0 +1,78 @@
+"""
+maten.core.linalg — linear algebra operations
+"""
+
+import math
+import operator
+from functools import reduce
+from maten.core.tensor import Tensor, matmul
+
+
+class linalg:
+
+    @staticmethod
+    def norm(t, ord=2):
+        if ord == 2:           return Tensor._make([math.sqrt(sum(x**2 for x in t._data))], (1,), float)
+        elif ord == 1:         return Tensor._make([sum(abs(x) for x in t._data)], (1,), float)
+        elif ord == float('inf'): return Tensor._make([max(abs(x) for x in t._data)], (1,), float)
+        raise ValueError(f"Unsupported norm order: {ord}")
+
+    @staticmethod
+    def dot(a, b):
+        return a.dot(b)
+
+    @staticmethod
+    def matmul(a, b):
+        return matmul(a, b)
+
+    @staticmethod
+    def transpose(t):
+        return t.T
+
+    @staticmethod
+    def trace(t):
+        assert t.ndim == 2 and t._shape[0] == t._shape[1]
+        n = t._shape[0]
+        return Tensor._make([sum(t._data[i * n + i] for i in range(n))], (1,), float)
+
+    @staticmethod
+    def det(t):
+        assert t.ndim == 2 and t._shape[0] == t._shape[1]
+        n   = t._shape[0]
+        from maten.core.tensor import _make_nested
+        mat = [row[:] for row in _make_nested(t._data, t._shape)]
+        det = 1.0
+        for col in range(n):
+            pivot = next((r for r in range(col, n) if abs(mat[r][col]) > 1e-12), None)
+            if pivot is None: return Tensor._make([0.0], (1,), float)
+            if pivot != col:
+                mat[col], mat[pivot] = mat[pivot], mat[col]; det *= -1
+            det *= mat[col][col]
+            for row in range(col + 1, n):
+                f = mat[row][col] / mat[col][col]
+                for k in range(col, n):
+                    mat[row][k] -= f * mat[col][k]
+        return Tensor._make([det], (1,), float)
+
+    @staticmethod
+    def inv(t):
+        assert t.ndim == 2 and t._shape[0] == t._shape[1]
+        n = t._shape[0]
+        from maten.core.tensor import _make_nested
+        mat = [row[:] for row in _make_nested(t._data, t._shape)]
+        inv = [[float(i == j) for j in range(n)] for i in range(n)]
+        for col in range(n):
+            pivot = next((r for r in range(col, n) if abs(mat[r][col]) > 1e-12), None)
+            if pivot is None: raise ValueError("Matrix is singular")
+            mat[col], mat[pivot] = mat[pivot], mat[col]
+            inv[col], inv[pivot] = inv[pivot], inv[col]
+            scale = mat[col][col]
+            mat[col] = [v / scale for v in mat[col]]
+            inv[col] = [v / scale for v in inv[col]]
+            for row in range(n):
+                if row != col:
+                    f = mat[row][col]
+                    mat[row] = [mat[row][k] - f * mat[col][k] for k in range(n)]
+                    inv[row] = [inv[row][k] - f * inv[col][k] for k in range(n)]
+        flat = [v for row in inv for v in row]
+        return Tensor._make(flat, (n, n), float)

maten/core/math_ops.py

@@ -0,0 +1,56 @@
+"""
+maten.core.math_ops — mathematical functions
+"""
+
+import math
+from maten.core.tensor import Tensor
+
+
+def _apply(t, func):
+    if isinstance(t, (int, float)): return func(t)
+    return t.apply(func)
+
+def sqrt(t):    return _apply(t, math.sqrt)
+def exp(t):     return _apply(t, math.exp)
+def log(t):     return _apply(t, math.log)
+def log2(t):    return _apply(t, math.log2)
+def log10(t):   return _apply(t, math.log10)
+def sin(t):     return _apply(t, math.sin)
+def cos(t):     return _apply(t, math.cos)
+def tan(t):     return _apply(t, math.tan)
+def tanh(t):    return _apply(t, math.tanh)
+def abs_(t):    return _apply(t, abs)
+def ceil(t):    return _apply(t, math.ceil)
+def floor(t):   return _apply(t, math.floor)
+
+def sigmoid(t):
+    return _apply(t, lambda x: 1 / (1 + math.exp(-x)))
+
+def relu(t):
+    return _apply(t, lambda x: max(0.0, x))
+
+def leaky_relu(t, alpha=0.01):
+    return _apply(t, lambda x: x if x > 0 else alpha * x)
+
+def clip(t, min_val, max_val):
+    return _apply(t, lambda x: max(min_val, min(max_val, x)))
+
+def softmax(t):
+    m = max(t._data)
+    exps  = [math.exp(x - m) for x in t._data]
+    total = sum(exps)
+    return Tensor._make([e / total for e in exps], t._shape, float)
+
+def where(condition, x, y):
+    data = [a if c else b for c, a, b in zip(condition._data, x._data, y._data)]
+    return Tensor._make(data, condition._shape, x.dtype)
+
+def unique(t):
+    return sorted(set(t._data))
+
+def sort(t):
+    return Tensor._make(sorted(t._data), t._shape, t.dtype)
+
+def matmul(a, b):
+    from maten.core.tensor import matmul as _matmul
+    return _matmul(a, b)

maten/core/tensor.py

@@ -0,0 +1,250 @@
+"""
+maten.core.tensor — N-dimensional Tensor class
+"""
+
+import math
+import operator
+from functools import reduce
+from copy import deepcopy
+
+
+def _flat(nested):
+    if isinstance(nested, (int, float, bool)):
+        return [float(nested)]
+    out = []
+    for item in nested:
+        out.extend(_flat(item))
+    return out
+
+def _shape_of(nested):
+    if not isinstance(nested, list):
+        return ()
+    if not nested:
+        return (0,)
+    return (len(nested),) + _shape_of(nested[0])
+
+def _make_nested(flat, shape):
+    if len(shape) == 1:
+        return list(flat[:shape[0]])
+    size = reduce(operator.mul, shape[1:], 1)
+    return [_make_nested(flat[i*size:(i+1)*size], shape[1:]) for i in range(shape[0])]
+
+def _broadcast_shapes(a, b):
+    ra, rb = list(reversed(a)), list(reversed(b))
+    out = []
+    for i in range(max(len(ra), len(rb))):
+        da = ra[i] if i < len(ra) else 1
+        db = rb[i] if i < len(rb) else 1
+        if da == db:     out.append(da)
+        elif da == 1:    out.append(db)
+        elif db == 1:    out.append(da)
+        else: raise ValueError(f"Cannot broadcast shapes {a} and {b}")
+    return tuple(reversed(out))
+
+
+class Tensor:
+    """N-dimensional array — core data structure of maten."""
+
+    def __init__(self, data, dtype=float, shape=None):
+        if isinstance(data, Tensor):
+            self._data  = data._data[:]
+            self._shape = data._shape
+        elif isinstance(data, list):
+            self._data  = [dtype(x) for x in _flat(data)]
+            self._shape = shape if shape else _shape_of(data)
+        elif isinstance(data, (int, float)):
+            self._data  = [dtype(data)]
+            self._shape = ()
+        else:
+            raise TypeError(f"Unsupported type: {type(data)}")
+        self.dtype = dtype
+
+    # ── internal factory ──────────────────────────────────────
+    @classmethod
+    def _make(cls, data, shape, dtype=float):
+        t = cls.__new__(cls)
+        t._data  = data
+        t._shape = shape
+        t.dtype  = dtype
+        return t
+
+    # ── properties ────────────────────────────────────────────
+    @property
+    def shape(self): return self._shape
+
+    @property
+    def ndim(self): return len(self._shape)
+
+    @property
+    def size(self): return len(self._data)
+
+    @property
+    def T(self):
+        if self.ndim != 2:
+            raise ValueError("Transpose only supports 2D tensors.")
+        r, c = self._shape
+        data = [self._data[j * c + i] for i in range(c) for j in range(r)]
+        return Tensor._make(data, (c, r), self.dtype)
+
+    # ── indexing ──────────────────────────────────────────────
+    def _flat_index(self, idx):
+        strides, s = [], 1
+        for d in reversed(self._shape):
+            strides.insert(0, s); s *= d
+        return sum(i * st for i, st in zip(idx, strides))
+
+    def __getitem__(self, idx):
+        if isinstance(idx, tuple):
+            return self._data[self._flat_index(idx)]
+        if isinstance(idx, int):
+            if self.ndim == 1:
+                return self._data[idx]
+            size = self.size // self._shape[0]
+            sub  = self._data[idx * size:(idx + 1) * size]
+            return Tensor._make(sub, self._shape[1:], self.dtype)
+        raise TypeError(f"Invalid index: {idx}")
+
+    def __setitem__(self, idx, value):
+        if isinstance(idx, int) and self.ndim == 1:
+            self._data[idx] = self.dtype(value)
+        elif isinstance(idx, tuple):
+            self._data[self._flat_index(idx)] = self.dtype(value)
+
+    # ── repr ──────────────────────────────────────────────────
+    def __repr__(self):
+        nested = _make_nested(self._data, self._shape) if self._shape else self._data[0]
+        return f"Tensor({nested}, shape={self._shape}, dtype={self.dtype.__name__})"
+
+    def tolist(self):
+        return _make_nested(self._data, self._shape) if self._shape else self._data[0]
+
+    # ── broadcast ─────────────────────────────────────────────
+    def broadcast_to(self, shape):
+        if self._shape == shape:
+            return self
+        padded  = (1,) * (len(shape) - len(self._shape)) + self._shape
+        repeats = [s // p for s, p in zip(shape, padded)]
+        data    = self._data[:]
+        cur     = list(padded)
+        for axis, rep in enumerate(repeats):
+            if rep > 1:
+                sb = reduce(operator.mul, cur[:axis], 1)
+                sa = reduce(operator.mul, cur[axis:], 1) // cur[axis]
+                nd = []
+                for i in range(sb):
+                    chunk = data[i * sa * cur[axis]:(i + 1) * sa * cur[axis]]
+                    for _ in range(rep):
+                        nd.extend(chunk[:sa])
+                data = nd
+                cur[axis] *= rep
+        return Tensor._make(data, shape, self.dtype)
+
+    # ── element-wise ops ──────────────────────────────────────
+    def _ew(self, other, op):
+        if isinstance(other, (int, float)):
+            return Tensor._make([op(x, other) for x in self._data], self._shape, self.dtype)
+        if isinstance(other, Tensor):
+            s = _broadcast_shapes(self._shape, other._shape)
+            a = self.broadcast_to(s);  b = other.broadcast_to(s)
+            return Tensor._make([op(x, y) for x, y in zip(a._data, b._data)], s, self.dtype)
+        raise TypeError(f"Unsupported: {type(other)}")
+
+    def __add__(self, o):  return self._ew(o, operator.add)
+    def __radd__(self, o): return self._ew(o, operator.add)
+    def __sub__(self, o):  return self._ew(o, operator.sub)
+    def __rsub__(self, o): return self._ew(o, lambda a, b: b - a)
+    def __mul__(self, o):  return self._ew(o, operator.mul)
+    def __rmul__(self, o): return self._ew(o, operator.mul)
+    def __truediv__(self, o):  return self._ew(o, operator.truediv)
+    def __rtruediv__(self, o): return self._ew(o, lambda a, b: b / a)
+    def __pow__(self, e):  return self._ew(e, operator.pow)
+    def __neg__(self):     return Tensor._make([-x for x in self._data], self._shape, self.dtype)
+    def __abs__(self):     return Tensor._make([abs(x) for x in self._data], self._shape, self.dtype)
+
+    def __eq__(self, o):   return self._ew(o, lambda a, b: float(a == b))
+    def __lt__(self, o):   return self._ew(o, lambda a, b: float(a < b))
+    def __le__(self, o):   return self._ew(o, lambda a, b: float(a <= b))
+    def __gt__(self, o):   return self._ew(o, lambda a, b: float(a > b))
+    def __ge__(self, o):   return self._ew(o, lambda a, b: float(a >= b))
+
+    # ── reductions ────────────────────────────────────────────
+    def sum(self, axis=None):
+        if axis is None:
+            return Tensor._make([sum(self._data)], (1,), self.dtype)
+        os = self._shape[:axis] + self._shape[axis+1:]
+        osz = reduce(operator.mul, os, 1) if os else 1
+        res = [0.0] * osz
+        sa  = reduce(operator.mul, self._shape[axis+1:], 1)
+        sb  = reduce(operator.mul, self._shape[:axis], 1)
+        for i in range(sb):
+            for k in range(self._shape[axis]):
+                for j in range(sa):
+                    res[i * sa + j] += self._data[i * self._shape[axis] * sa + k * sa + j]
+        return Tensor._make(res, os if os else (1,), self.dtype)
+
+    def mean(self, axis=None):
+        if axis is None:
+            return Tensor._make([sum(self._data) / len(self._data)], (1,), self.dtype)
+        return self.sum(axis=axis) / self._shape[axis]
+
+    def std(self, axis=None):
+        m    = self.mean(axis=axis)
+        diff = self - m
+        return ((diff * diff).mean(axis=axis)) ** 0.5
+
+    def max(self, axis=None):
+        if axis is None:
+            return Tensor._make([max(self._data)], (1,), self.dtype)
+        raise NotImplementedError("axis max coming soon")
+
+    def min(self, axis=None):
+        if axis is None:
+            return Tensor._make([min(self._data)], (1,), self.dtype)
+        raise NotImplementedError("axis min coming soon")
+
+    def argmax(self): return self._data.index(max(self._data))
+    def argmin(self): return self._data.index(min(self._data))
+
+    # ── shape ops ─────────────────────────────────────────────
+    def reshape(self, *shape):
+        s = shape[0] if len(shape) == 1 and isinstance(shape[0], tuple) else shape
+        if -1 in s:
+            known = reduce(operator.mul, [x for x in s if x != -1], 1)
+            s = tuple(self.size // known if x == -1 else x for x in s)
+        assert reduce(operator.mul, s, 1) == self.size, "Shape mismatch"
+        return Tensor._make(self._data[:], s, self.dtype)
+
+    def flatten(self):      return self.reshape(self.size)
+    def squeeze(self):      return self.reshape(tuple(s for s in self._shape if s != 1) or (1,))
+    def expand_dims(self, axis):
+        s = list(self._shape); s.insert(axis, 1)
+        return self.reshape(tuple(s))
+
+    # ── matrix ops ────────────────────────────────────────────
+    def dot(self, other):
+        if self.ndim == 1 and other.ndim == 1:
+            return Tensor._make([sum(a * b for a, b in zip(self._data, other._data))], (1,), self.dtype)
+        return matmul(self, other)
+
+    def __matmul__(self, other): return matmul(self, other)
+
+    def apply(self, func):
+        return Tensor._make([func(x) for x in self._data], self._shape, self.dtype)
+
+
+def matmul(a, b):
+    assert a.ndim == 2 and b.ndim == 2
+    m, k  = a._shape;  k2, n = b._shape
+    assert k == k2, f"Shape mismatch: {k} != {k2}"
+    res = [0.0] * (m * n)
+    for i in range(m):
+        for j in range(n):
+            s = 0.0
+            for p in range(k):
+                s += a._data[i * k + p] * b._data[p * n + j]
+            res[i * n + j] = s
+    return Tensor._make(res, (m, n), float)
+
+
+def array(data, dtype=float):
+    return Tensor(data, dtype=dtype)

maten/frame/__init__.py

@@ -0,0 +1,15 @@
+"""Pandas-like Series and DataFrame utilities."""
+
+from maten.frame.dataframe import DataFrame
+from maten.frame.groupby import GroupBy
+from maten.frame.io import concat, read_csv, read_json
+from maten.frame.series import Series
+
+__all__ = [
+    "Series",
+    "DataFrame",
+    "GroupBy",
+    "read_csv",
+    "read_json",
+    "concat",
+]