heropy 0.1.0__tar.gz

heropy-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: heropy
+Version: 0.1.0
+Summary: A high-performance fundamental package for scientific computing with multi-dimensional arrays, linear algebra, and FFT.
+Author-email: Death Legion Team <contact@deathlegion.team>
+Project-URL: Homepage, https://github.com/deathlegion/heropy
+Project-URL: Bug Tracker, https://github.com/deathlegion/heropy/issues
+Keywords: scientific computing,multi-dimensional arrays,linear algebra,FFT,matrix,numerical computing,data science,machine learning
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# HeroPy: High-Performance Scientific Computing in Python
+
+HeroPy is the fundamental package for scientific computing with Python, meticulously crafted by the **Death Legion Team**. It provides a powerful N-dimensional array object, sophisticated mathematical functions, and the core data structures necessary for modern data science and machine learning.
+
+[![PyPI version](https://badge.fury.io/py/heropy.svg)](https://badge.fury.io/py/heropy)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Why HeroPy?
+
+In the evolving landscape of numerical computing, HeroPy stands as a robust foundation for handling large, multi-dimensional arrays and matrices. Designed for performance and ease of use, HeroPy enables complex mathematical operations on entire blocks of data without the need for slow Python loops.
+
+## Core Features
+
+- **N-Dimensional Array (`ndarray`)**: A versatile, multi-dimensional array object with support for advanced indexing, slicing, and NumPy-style broadcasting.
+- **Linear Algebra (`linalg`)**: High-level mathematical functions for matrix multiplication (`dot`), transposition, and vector operations.
+- **Fourier Transforms (`fft`)**: Efficient Fast Fourier Transform (FFT) capabilities for signal processing and spectral analysis.
+- **Random Number Generation (`random`)**: Sophisticated random number generation with support for various distributions like Uniform and Normal (Gaussian).
+- **Extensible Architecture**: Built to be the bedrock of the Python data science ecosystem, compatible with machine learning and data analysis workflows.
+
+## Installation
+
+```bash
+# Clone the repository
+git clone <repo-url>
+cd heropy
+export PYTHONPATH=$PYTHONPATH:.
+```
+
+## Usage
+
+```python
+import heropy as hp
+from heropy.linalg import dot
+
+# Create arrays
+a = hp.ndarray([[1, 2], [3, 4]])
+b = hp.ndarray([10, 20])
+
+# Arithmetic with broadcasting
+c = a + b
+
+# Matrix multiplication
+d = dot(a, a)
+
+# FFT
+from heropy.fft import fft
+freq = fft([1, 0, 1, 0])
+```
+
+## Performance Note
+
+HeroPy is currently implemented in pure Python for maximum portability and clarity. While it provides the core data structures and operations, performance for very large datasets may be limited compared to C-accelerated libraries.

heropy-0.1.0/README.md

@@ -0,0 +1,52 @@
+# HeroPy: High-Performance Scientific Computing in Python
+
+HeroPy is the fundamental package for scientific computing with Python, meticulously crafted by the **Death Legion Team**. It provides a powerful N-dimensional array object, sophisticated mathematical functions, and the core data structures necessary for modern data science and machine learning.
+
+[![PyPI version](https://badge.fury.io/py/heropy.svg)](https://badge.fury.io/py/heropy)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Why HeroPy?
+
+In the evolving landscape of numerical computing, HeroPy stands as a robust foundation for handling large, multi-dimensional arrays and matrices. Designed for performance and ease of use, HeroPy enables complex mathematical operations on entire blocks of data without the need for slow Python loops.
+
+## Core Features
+
+- **N-Dimensional Array (`ndarray`)**: A versatile, multi-dimensional array object with support for advanced indexing, slicing, and NumPy-style broadcasting.
+- **Linear Algebra (`linalg`)**: High-level mathematical functions for matrix multiplication (`dot`), transposition, and vector operations.
+- **Fourier Transforms (`fft`)**: Efficient Fast Fourier Transform (FFT) capabilities for signal processing and spectral analysis.
+- **Random Number Generation (`random`)**: Sophisticated random number generation with support for various distributions like Uniform and Normal (Gaussian).
+- **Extensible Architecture**: Built to be the bedrock of the Python data science ecosystem, compatible with machine learning and data analysis workflows.
+
+## Installation
+
+```bash
+# Clone the repository
+git clone <repo-url>
+cd heropy
+export PYTHONPATH=$PYTHONPATH:.
+```
+
+## Usage
+
+```python
+import heropy as hp
+from heropy.linalg import dot
+
+# Create arrays
+a = hp.ndarray([[1, 2], [3, 4]])
+b = hp.ndarray([10, 20])
+
+# Arithmetic with broadcasting
+c = a + b
+
+# Matrix multiplication
+d = dot(a, a)
+
+# FFT
+from heropy.fft import fft
+freq = fft([1, 0, 1, 0])
+```
+
+## Performance Note
+
+HeroPy is currently implemented in pure Python for maximum portability and clarity. While it provides the core data structures and operations, performance for very large datasets may be limited compared to C-accelerated libraries.

heropy-0.1.0/heropy/__init__.py

@@ -0,0 +1 @@
+from .core import ndarray

heropy-0.1.0/heropy/core.py

@@ -0,0 +1,213 @@
+import math
+import itertools
+
+class ndarray:
+    def __init__(self, data):
+        if isinstance(data, ndarray):
+            self._data = [x for x in data._data]
+            self._shape = data._shape
+        else:
+            self._data, self._shape = self._process_data(data)
+        
+        self.size = 1
+        for dim in self._shape:
+            self.size *= dim
+
+    def _process_data(self, data):
+        if not isinstance(data, (list, tuple)):
+            return [data], ()
+        
+        shape = []
+        curr = data
+        while isinstance(curr, (list, tuple)):
+            shape.append(len(curr))
+            if len(curr) == 0:
+                break
+            curr = curr[0]
+        
+        def flatten(lst):
+            res = []
+            for item in lst:
+                if isinstance(item, (list, tuple)):
+                    res.extend(flatten(item))
+                else:
+                    res.append(item)
+            return res
+        
+        return flatten(data), tuple(shape)
+
+    @property
+    def shape(self):
+        return self._shape
+
+    def __repr__(self):
+        return f"ndarray({self._data}, shape={self._shape})"
+
+    def __len__(self):
+        if not self._shape:
+            return 0
+        return self._shape[0]
+
+    def _get_index(self, key):
+        if not isinstance(key, tuple):
+            key = (key,)
+        
+        if len(key) > len(self._shape):
+            raise IndexError("Too many indices for array")
+        
+        # Pad with full slices if necessary
+        key = list(key)
+        while len(key) < len(self._shape):
+            key.append(slice(None))
+        
+        return key
+
+    def _resolve_key(self, key):
+        key = self._get_index(key)
+        slices = []
+        is_single = True
+        for i, k in enumerate(key):
+            if isinstance(k, int):
+                slices.append(slice(k, k + 1))
+            else:
+                slices.append(k)
+                is_single = False
+        
+        new_shape = []
+        ranges = []
+        for i, s in enumerate(slices):
+            start, stop, step = s.indices(self._shape[i])
+            ranges.append(range(start, stop, step))
+            if not isinstance(key[i], int):
+                new_shape.append(len(ranges[-1]))
+        
+        return ranges, tuple(new_shape), is_single
+
+    def __getitem__(self, key):
+        ranges, new_shape, is_single = self._resolve_key(key)
+        
+        new_data = []
+        for coords in itertools.product(*ranges):
+            idx = 0
+            stride = 1
+            for i in range(len(self._shape) - 1, -1, -1):
+                idx += coords[i] * stride
+                stride *= self._shape[i]
+            new_data.append(self._data[idx])
+        
+        if is_single:
+            return new_data[0]
+            
+        res = ndarray(0)
+        res._data = new_data
+        res._shape = new_shape
+        res.size = len(new_data)
+        return res
+
+    def __setitem__(self, key, value):
+        ranges, _, is_single = self._resolve_key(key)
+        
+        if is_single:
+            idx = 0
+            stride = 1
+            coords = [r.start for r in ranges]
+            for i in range(len(self._shape) - 1, -1, -1):
+                idx += coords[i] * stride
+                stride *= self._shape[i]
+            self._data[idx] = value
+            return
+
+        if isinstance(value, ndarray):
+            val_data = value._data
+        elif isinstance(value, (list, tuple)):
+            val_data = ndarray(value)._data
+        else:
+            val_data = itertools.cycle([value])
+
+        for i, coords in enumerate(itertools.product(*ranges)):
+            idx = 0
+            stride = 1
+            for j in range(len(self._shape) - 1, -1, -1):
+                idx += coords[j] * stride
+                stride *= self._shape[j]
+            
+            if isinstance(val_data, itertools.cycle):
+                self._data[idx] = next(val_data)
+            else:
+                self._data[idx] = val_data[i]
+
+    def __add__(self, other):
+        return self._binary_op(other, lambda x, y: x + y)
+
+    def __sub__(self, other):
+        return self._binary_op(other, lambda x, y: x - y)
+
+    def __mul__(self, other):
+        return self._binary_op(other, lambda x, y: x * y)
+
+    def __truediv__(self, other):
+        return self._binary_op(other, lambda x, y: x / y)
+
+    def __radd__(self, other):
+        return ndarray(other) + self
+
+    def __rsub__(self, other):
+        return ndarray(other) - self
+
+    def __rmul__(self, other):
+        return ndarray(other) * self
+
+    def __rtruediv__(self, other):
+        return ndarray(other) / self
+
+    def _binary_op(self, other, op):
+        if not isinstance(other, ndarray):
+            other = ndarray(other)
+        
+        # Get common shape for broadcasting
+        s1 = self.shape
+        s2 = other.shape
+        
+        # Pad shapes with 1s to match lengths
+        l1, l2 = len(s1), len(s2)
+        n = max(l1, l2)
+        p1 = (1,) * (n - l1) + s1
+        p2 = (1,) * (n - l2) + s2
+        
+        out_shape = []
+        for d1, d2 in zip(p1, p2):
+            if d1 == d2:
+                out_shape.append(d1)
+            elif d1 == 1:
+                out_shape.append(d2)
+            elif d2 == 1:
+                out_shape.append(d1)
+            else:
+                raise ValueError(f"Operands could not be broadcast together with shapes {s1} {s2}")
+        
+        out_shape = tuple(out_shape)
+        
+        # Simple but slow broadcasting implementation
+        ranges = [range(d) for d in out_shape]
+        new_data = []
+        for coords in itertools.product(*ranges):
+            # Map coords back to original shapes
+            c1 = []
+            for i in range(l1):
+                dim_idx = i + (n - l1)
+                c1.append(coords[dim_idx] if s1[i] > 1 else 0)
+            
+            c2 = []
+            for i in range(l2):
+                dim_idx = i + (n - l2)
+                c2.append(coords[dim_idx] if s2[i] > 1 else 0)
+            
+            v1 = self[tuple(c1)] if s1 else self._data[0]
+            v2 = other[tuple(c2)] if s2 else other._data[0]
+            new_data.append(op(v1, v2))
+            
+        res = ndarray(0)
+        res._data = new_data
+        res._shape = out_shape
+        res.size = len(new_data)
+        return res

heropy-0.1.0/heropy/fft.py

@@ -0,0 +1,41 @@
+import math
+import cmath
+from .core import ndarray
+
+def fft(x):
+    if not isinstance(x, ndarray):
+        x = ndarray(x)
+    
+    if len(x.shape) != 1:
+        raise ValueError("FFT only implemented for 1D arrays")
+    
+    n = x.size
+    if n <= 1:
+        return x
+    
+    # Cooley-Tukey FFT (recursive)
+    if n & (n - 1) != 0:
+        # Simple padding to next power of 2 for this basic implementation
+        next_pow2 = 1 << (n - 1).bit_length()
+        padded_data = x._data + [0] * (next_pow2 - n)
+        x = ndarray(padded_data)
+        n = next_pow2
+
+    def _fft(data):
+        n = len(data)
+        if n <= 1:
+            return data
+        
+        even = _fft(data[0::2])
+        odd = _fft(data[1::2])
+        
+        T = [cmath.exp(-2j * math.pi * k / n) * odd[k] for k in range(n // 2)]
+        return [even[k] + T[k] for k in range(n // 2)] + \
+               [even[k] - T[k] for k in range(n // 2)]
+
+    res_data = _fft(x._data)
+    res = ndarray(0)
+    res._data = res_data
+    res._shape = (len(res_data),)
+    res.size = len(res_data)
+    return res

heropy-0.1.0/heropy/linalg.py

@@ -0,0 +1,53 @@
+from .core import ndarray
+
+def transpose(a):
+    if not isinstance(a, ndarray):
+        a = ndarray(a)
+    
+    if len(a.shape) != 2:
+        raise ValueError("Transpose only implemented for 2D arrays")
+    
+    rows, cols = a.shape
+    new_data = [0] * a.size
+    for r in range(rows):
+        for c in range(cols):
+            new_data[c * rows + r] = a[r, c]
+            
+    res = ndarray(0)
+    res._data = new_data
+    res._shape = (cols, rows)
+    res.size = a.size
+    return res
+
+def dot(a, b):
+    if not isinstance(a, ndarray): a = ndarray(a)
+    if not isinstance(b, ndarray): b = ndarray(b)
+    
+    # Simple vector dot product
+    if len(a.shape) == 1 and len(b.shape) == 1:
+        if a.shape[0] != b.shape[0]:
+            raise ValueError("Shapes not compatible for dot product")
+        return sum(x * y for x, y in zip(a._data, b._data))
+    
+    # Matrix multiplication
+    if len(a.shape) == 2 and len(b.shape) == 2:
+        r1, c1 = a.shape
+        r2, c2 = b.shape
+        if c1 != r2:
+            raise ValueError("Shapes not compatible for matrix multiplication")
+        
+        new_data = [0] * (r1 * c2)
+        for i in range(r1):
+            for j in range(c2):
+                s = 0
+                for k in range(c1):
+                    s += a[i, k] * b[k, j]
+                new_data[i * c2 + j] = s
+        
+        res = ndarray(0)
+        res._data = new_data
+        res._shape = (r1, c2)
+        res.size = r1 * c2
+        return res
+
+    raise NotImplementedError("Dot product only implemented for 1D/2D arrays")

heropy-0.1.0/heropy/random.py

@@ -0,0 +1,39 @@
+import random as py_random
+import math
+from .core import ndarray
+
+def uniform(low=0.0, high=1.0, size=None):
+    if size is None:
+        return py_random.uniform(low, high)
+    
+    if isinstance(size, int):
+        size = (size,)
+    
+    total_size = 1
+    for dim in size:
+        total_size *= dim
+    
+    data = [py_random.uniform(low, high) for _ in range(total_size)]
+    res = ndarray(0)
+    res._data = data
+    res._shape = tuple(size)
+    res.size = total_size
+    return res
+
+def normal(loc=0.0, scale=1.0, size=None):
+    if size is None:
+        return py_random.gauss(loc, scale)
+    
+    if isinstance(size, int):
+        size = (size,)
+    
+    total_size = 1
+    for dim in size:
+        total_size *= dim
+    
+    data = [py_random.gauss(loc, scale) for _ in range(total_size)]
+    res = ndarray(0)
+    res._data = data
+    res._shape = tuple(size)
+    res.size = total_size
+    return res

heropy-0.1.0/heropy/tests/test_all.py

@@ -0,0 +1,58 @@
+import unittest
+from heropy import ndarray
+from heropy.linalg import dot, transpose
+from heropy.fft import fft
+from heropy.random import uniform, normal
+
+class TestHeroPy(unittest.TestCase):
+    def test_core_init(self):
+        a = ndarray([[1, 2], [3, 4]])
+        self.assertEqual(a.shape, (2, 2))
+        self.assertEqual(a.size, 4)
+
+    def test_indexing(self):
+        a = ndarray([[1, 2], [3, 4]])
+        self.assertEqual(a[0, 1], 2)
+        a[1, 1] = 10
+        self.assertEqual(a[1, 1], 10)
+
+    def test_arithmetic(self):
+        a = ndarray([1, 2, 3])
+        b = ndarray([4, 5, 6])
+        self.assertEqual((a + b)._data, [5, 7, 9])
+        self.assertEqual((a * 2)._data, [2, 4, 6])
+        self.assertEqual((10 / a)._data[0], 10.0)
+
+    def test_linalg(self):
+        a = ndarray([[1, 2], [3, 4]])
+        at = transpose(a)
+        self.assertEqual(at[0, 1], 3)
+        
+        b = ndarray([[5, 6], [7, 8]])
+        c = dot(a, b)
+        self.assertEqual(c[0, 0], 19)
+
+    def test_fft(self):
+        x = [1, 0, 0, 0]
+        res = fft(x)
+        self.assertAlmostEqual(res._data[0], 1.0)
+        self.assertAlmostEqual(res._data[3], 1.0)
+
+    def test_random(self):
+        u = uniform(0, 1, size=(10, 10))
+        self.assertEqual(u.shape, (10, 10))
+
+    def test_slicing(self):
+        a = ndarray([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        b = a[0:2, 1:3]
+        self.assertEqual(b.shape, (2, 2))
+        self.assertEqual(b._data, [2, 3, 5, 6])
+
+    def test_broadcasting_complex(self):
+        a = ndarray([[1, 2, 3], [4, 5, 6]])
+        b = ndarray([10, 20, 30])
+        c = a + b
+        self.assertEqual(c._data, [11, 22, 33, 14, 25, 36])
+
+if __name__ == "__main__":
+    unittest.main()

heropy-0.1.0/heropy.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: heropy
+Version: 0.1.0
+Summary: A high-performance fundamental package for scientific computing with multi-dimensional arrays, linear algebra, and FFT.
+Author-email: Death Legion Team <contact@deathlegion.team>
+Project-URL: Homepage, https://github.com/deathlegion/heropy
+Project-URL: Bug Tracker, https://github.com/deathlegion/heropy/issues
+Keywords: scientific computing,multi-dimensional arrays,linear algebra,FFT,matrix,numerical computing,data science,machine learning
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# HeroPy: High-Performance Scientific Computing in Python
+
+HeroPy is the fundamental package for scientific computing with Python, meticulously crafted by the **Death Legion Team**. It provides a powerful N-dimensional array object, sophisticated mathematical functions, and the core data structures necessary for modern data science and machine learning.
+
+[![PyPI version](https://badge.fury.io/py/heropy.svg)](https://badge.fury.io/py/heropy)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Why HeroPy?
+
+In the evolving landscape of numerical computing, HeroPy stands as a robust foundation for handling large, multi-dimensional arrays and matrices. Designed for performance and ease of use, HeroPy enables complex mathematical operations on entire blocks of data without the need for slow Python loops.
+
+## Core Features
+
+- **N-Dimensional Array (`ndarray`)**: A versatile, multi-dimensional array object with support for advanced indexing, slicing, and NumPy-style broadcasting.
+- **Linear Algebra (`linalg`)**: High-level mathematical functions for matrix multiplication (`dot`), transposition, and vector operations.
+- **Fourier Transforms (`fft`)**: Efficient Fast Fourier Transform (FFT) capabilities for signal processing and spectral analysis.
+- **Random Number Generation (`random`)**: Sophisticated random number generation with support for various distributions like Uniform and Normal (Gaussian).
+- **Extensible Architecture**: Built to be the bedrock of the Python data science ecosystem, compatible with machine learning and data analysis workflows.
+
+## Installation
+
+```bash
+# Clone the repository
+git clone <repo-url>
+cd heropy
+export PYTHONPATH=$PYTHONPATH:.
+```
+
+## Usage
+
+```python
+import heropy as hp
+from heropy.linalg import dot
+
+# Create arrays
+a = hp.ndarray([[1, 2], [3, 4]])
+b = hp.ndarray([10, 20])
+
+# Arithmetic with broadcasting
+c = a + b
+
+# Matrix multiplication
+d = dot(a, a)
+
+# FFT
+from heropy.fft import fft
+freq = fft([1, 0, 1, 0])
+```
+
+## Performance Note
+
+HeroPy is currently implemented in pure Python for maximum portability and clarity. While it provides the core data structures and operations, performance for very large datasets may be limited compared to C-accelerated libraries.

heropy-0.1.0/heropy.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+heropy/__init__.py
+heropy/core.py
+heropy/fft.py
+heropy/linalg.py
+heropy/random.py
+heropy.egg-info/PKG-INFO
+heropy.egg-info/SOURCES.txt
+heropy.egg-info/dependency_links.txt
+heropy.egg-info/top_level.txt
+heropy/tests/__init__.py
+heropy/tests/test_all.py

heropy-0.1.0/heropy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

heropy-0.1.0/heropy.egg-info/top_level.txt

@@ -0,0 +1 @@
+heropy

heropy-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "heropy"
+version = "0.1.0"
+authors = [
+  { name="Death Legion Team", email="contact@deathlegion.team" },
+]
+description = "A high-performance fundamental package for scientific computing with multi-dimensional arrays, linear algebra, and FFT."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Developers",
+]
+keywords = ["scientific computing", "multi-dimensional arrays", "linear algebra", "FFT", "matrix", "numerical computing", "data science", "machine learning"]
+
+[project.urls]
+"Homepage" = "https://github.com/deathlegion/heropy"
+"Bug Tracker" = "https://github.com/deathlegion/heropy/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["heropy*"]

heropy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+