ironforest 0.2__cp313-cp313-macosx_10_12_x86_64.whl

ironforest/__init__.py

@@ -0,0 +1,37 @@
+"""Substratum: N-dimensional array library for numerical computation and spatial analysis."""
+
+from ironforest._core import (
+    Array,
+    zeros,
+    ones,
+    full,
+    asarray,
+    eye,
+    diag,
+    column_stack,
+    linalg,
+    stats,
+    random,
+    spatial,
+)
+
+# Import pure Python modules
+from . import models
+
+__all__ = [
+    "Array",
+    "zeros",
+    "ones",
+    "full",
+    "asarray",
+    "eye",
+    "diag",
+    "column_stack",
+    "linalg",
+    "stats",
+    "random",
+    "spatial",
+    "models",
+]
+
+__version__ = "0.2"

ironforest/linear_regression.py

@@ -0,0 +1,108 @@
+from ironforest import Array, linalg, column_stack
+
+class LinearRegression:
+    """Linear regression model using least squares."""
+    
+    def __init__(self, fit_intercept: bool = True):
+        """
+        Initialize linear regression model.
+        
+        Args:
+            fit_intercept: Whether to calculate the intercept for this model.
+        """
+        self.fit_intercept = fit_intercept
+        self.coef_ = None
+        self.intercept_ = None
+        self._is_fitted = False
+    
+    def fit(self, X: Array, y: Array) -> 'LinearRegression':
+        """
+        Fit linear model.
+        
+        Args:
+            X: Training data of shape (n_samples, n_features)
+            y: Target values of shape (n_samples,) or (n_samples, n_targets)
+        
+        Returns:
+            self: Fitted estimator
+        """
+        if self.fit_intercept:
+            ones = Array.ones((X.shape[0], 1))
+            X_design = column_stack([ones, X])
+        else:
+            X_design = X
+
+        params, _ = linalg.lstsq(X_design, y)
+        
+        if self.fit_intercept:
+            self.intercept_ = params[0]
+            self.coef_ = params[1:]
+        else:
+            self.intercept_ = 0.0
+            self.coef_ = params
+        
+        self._is_fitted = True
+        return self
+    
+    def predict(self, X: Array) -> Array:
+        """
+        Predict using the linear model.
+        
+        Args:
+            X: Samples of shape (n_samples, n_features)
+        
+        Returns:
+            Predicted values of shape (n_samples,) or (n_samples, n_targets)
+        
+        Raises:
+            RuntimeError: If model hasn't been fitted yet
+        """
+        if not self._is_fitted:
+            raise RuntimeError("Model must be fitted before calling predict")
+        
+        y_pred = X @ self.coef_ # type: ignore
+        
+        if self.fit_intercept:
+            y_pred = y_pred + self.intercept_ # type: ignore
+        
+        return y_pred
+    
+    def score(self, X: Array, y: Array) -> float:
+        """
+        Return the coefficient of determination (R²) of the prediction.
+        
+        Args:
+            X: Test samples of shape (n_samples, n_features)
+            y: True values of shape (n_samples,) or (n_samples, n_targets)
+        
+        Returns:
+            R² score
+        """
+        if not self._is_fitted:
+            raise RuntimeError("Model must be fitted before calling score")
+        
+        y_pred = self.predict(X)
+        
+        pred_dif = y - y_pred
+        mean_diff = y - y.mean()
+
+        ss_res = (pred_dif * pred_dif).sum()
+        ss_tot = (mean_diff * mean_diff).sum()
+        
+        return 1.0 - (ss_res / ss_tot)
+    
+    def residuals(self, X: Array, y: Array) -> Array:
+        """
+        Calculate residuals (y - y_pred).
+        
+        Args:
+            X: Samples of shape (n_samples, n_features)
+            y: True values of shape (n_samples,) or (n_samples, n_targets)
+        
+        Returns:
+            Residuals array
+        """
+        if not self._is_fitted:
+            raise RuntimeError("Model must be fitted before calculating residuals")
+        
+        return y - self.predict(X)

ironforest/models.py

@@ -0,0 +1,5 @@
+"""Machine learning models built on top of ironforest."""
+
+from .linear_regression import LinearRegression
+
+__all__ = ["LinearRegression"]

ironforest-0.2.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: ironforest
+Version: 0.2
+Summary: An library supporting numerical computation and spatial analysis.
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# IronForest
+IronForest is a rust-powered python library supporting spatial queries, array-based computation and tree-based machine learning. 
+
+I started this project to support my previous python library dubious, a project which had the personal constraint of no external dependecies other than numpy. IronForest started as a way for me to eliminate numpy as dubious's lone dependency but has since grown into a standalone project as I have pivoted towards spatial indexing trees and tree-based models. The core rational behind this project was to get a better grasp of how libraries I use on a regular basis work, and learn how to write python bindings to offload computationally expensive tasks to tools better suited. Like dubious, I focused on building things from the ground up. I didn't want to glue dependecies together to get something functional, I wanted to understand from input to output how these algorithms worked under the hood. I chose rust because I had read the book around a year prior to starting this project, and pyo3 bindings are relitively easy to get working. This library is only exposed through python as that's where I've actually needed its features and I don't intend to package this as a rust create at this stage.
+
+## Status
+This is largely a learning project and the API is subject to change. We achieve similar performance to numpy (beating them in a rare few) across most operations but basic broadcasting arithmetic is around 4x slower in most cases. I intend to add a few unsafe methods to speed things up where applicable but I don't intend to optimize much further at this stage. 
+
+## Installation
+`pip install ironforest`
+
+You can also build with `maturin build --release` assuming maturin is installed.
+
+## Quickstart
+
+```python
+import ironforest as irn
+
+a = irn.Array([2, 2], [1.0, 2.0, 3.0, 4.0])
+b = irn.Array([2, 2], [5.0, 6.0, 7.0, 8.0])
+
+print(f"a @ b = {(a @ b).tolist()}")
+```
+Output: 
+`a @ b = [[19.0, 22.0], [43.0, 50.0]]`
+
+## Features
+- Array, an N-dimensional array object with broadcasting
+- matrix operations and constructors
+- KDTree, BallTree & VPTree with knn radius KDE and KDE approx queries
+- Linear and Local Regression
+- Decision trees, Random Forest and Isolation Forest
+- cholesky, qr and eigen decomposition
+- Least Squares & Weighted Least Squares Solver
+- Random sampling from uniform, normal lognormal, gamma and beta distributions.
+- Statistical methods (mean, median, var, std, quantile)
+- Pearson and Spearman correlation
+
+### Top-level
+- `ironforest.Array`
+
+### Modules
+- [ironforest.linalg](#linalg)
+- [ironforest.stats](#stats)
+- [ironforest.random](#random)
+- [ironforest.spatial](#spatial)
+- - [ironforest.model](#model)
+
+## Examples
+```python
+import ironforest as irn
+
+a = irn.Array([2, 2], [1.0, 2.0, 3.0, 4.0])
+b = irn.Array([2, 2], [5.0, 6.0, 7.0, 8.0])
+
+print(f"a + b = {(a + b).tolist()}")
+print(f"a * b = {(a * b).tolist()}")
+```
+Output: 
+`
+a + b = [[6.0, 8.0], [10.0, 12.0]]
+a * b = [[5.0, 12.0], [21.0, 32.0]]
+`
+```python
+import ironforest as irn
+
+gen = irn.Generator.from_seed(123)
+
+uniform = gen.uniform(0.0, 1.0, [2, 3])
+print(f"Uniform [0, 1): {uniform.tolist()}")
+
+normal = gen.standard_normal([2, 3])
+print(f"Standard normal: {normal.tolist()}")
+```
+Output: 
+`Uniform [0, 1): [0.19669435215621578, 0.9695722925002218, 0.46744032361670884, 0.12698379756585432]
+Standard normal: [-0.0008585765206425146, 1.4733334715623352, -1.16180050645278, -0.772101732825336]`
+
+## Modules
+
+### Random
+`Generator` object that can sample from uniform, normal, lognormal, gamma and beta distributions. Support for additional distributions is planned.
+
+### Linalg
+- Standard matrix methods and constructors.
+- cholesky and eigen and qr decomposition.
+- Least Squares & Weighted Least Squares solver.
+
+### Stats
+- Basic statistical methods for `Array` objects, mean, var and quantile.
+- Pearson and Spearman correlation.
+
+### Spatial
+- `KDTree` kNN, Kernel Density Estimation and radius queries. 
+- `BallTree` with kNN, Kernel Density Estimation and radius queries. 
+- `VPTree` with kNN, Kernel Density Estimation and radius queries.
+
+### Model
+- Linear Regression
+- Local Regression
+- Decision Trees (soon)
+- Random Forest (soon)
+- Isolation Forest (soon)
+

ironforest-0.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+ironforest/__init__.py,sha256=DEdGoxUrAA0bbFmIqlkPX3Egbmi8yCmJIQj84MlnWew,533
+ironforest/_core.cpython-313-darwin.so,sha256=2hbExunAG5Ou_a9N0rbSAuFniGyCJkYn8FN5GPLwbek,1172604
+ironforest/linear_regression.py,sha256=QQ-S44OIdrvSInsVknHFZ0zn95RwPsXt_M8MEvFzbM8,3183
+ironforest/models.py,sha256=Nw9JCPkp-oxqs0T0tzq3sirHzZdkleYfAkE12cdqLVE,138
+ironforest-0.2.dist-info/METADATA,sha256=mbAcSavMR1QC1dmbrlUyCKPb0lxd80fBbOUzxtzB_2M,4450
+ironforest-0.2.dist-info/WHEEL,sha256=y-bBezkr9XqWB_KK0tUa5PfJn4Rf73obH4dbo4t0ZEc,107
+ironforest-0.2.dist-info/RECORD,,

ironforest-0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp313-cp313-macosx_10_12_x86_64