natumpy 4.0.1__tar.gz

natumpy-4.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eternals
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

natumpy-4.0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: natumpy
+Version: 4.0.1
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python

natumpy-4.0.1/README.md

@@ -0,0 +1,215 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python: 3.8+](https://img.shields.io/badge/python-3.8%2B-blue)](https://www.python.org/downloads/)
+[![Architecture: Nawa](https://img.shields.io/badge/Architecture-Complex%20Valued-purple)]()
+
+> **"Beyond Probability. Into Dynamics."**
+
+**natumpy** is a high-performance C++ extension implementing the **Nawa Architecture**: a deterministic, complex-valued dynamical system designed for next-generation AI reasoning.
+
+Unlike traditional neural networks that rely on statistical inference (matrix multiplication), Nawa models intelligence as **coupled oscillators** on a high-dimensional graph. It leverages **Symplectic Integration** (Hamiltonian Mechanics) to ensure energy conservation and reversible logic, and uses **Complex Numbers** to enable signal superposition and phase-dependent gating.
+
+---
+
+## Core Concepts
+
+### 1. The "Superposition" Hijack
+Standard AI uses scalar values ($x$). Nawa uses **Complex State Vectors** ($z = r + i\theta$).
+* **Real Component ($r$):** Represents Magnitude/Activation strength.
+* **Imaginary Component ($\theta$):** Represents Phase/Timing.
+* **Benefit:** Allows orthogonal information processing. Two signals can travel through the same node without corruption if their phases are orthogonal.
+
+### 2. Symplectic Integrator
+We do not use simple Euler integration. Nawa employs a **Semi-Implicit Symplectic Solver**.
+* **Stability:** Guarantees that the phase-space volume is preserved.
+* **Reversibility:** The system logic can be reversed in time ($t \to -t$) to trace cause-and-effect.
+
+### 3. Struct of Arrays (SoA)
+Optimized for modern CPU Cache and SIMD (Single Instruction, Multiple Data). Data is separated into contiguous memory blocks (`q_r`, `q_i`, `p_r`, `p_i`) ensuring maximum throughput during physics stepping.
+# NATUMPY
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue)](https://www.python.org/downloads/)
+[![Build Status](https://img.shields.io/badge/build-passing-brightgreen)]()
+
+**natumpy** is a highly optimized C++ extension for Python, designed to facilitate efficient numerical field simulations and particle physics modeling. It leverages a C++17 core engine exposed through the Python C-API, providing direct memory access via NumPy without the overhead of data copying.
+
+This library is engineered for production environments requiring low-latency physics stepping, thread safety, and seamless integration with the scientific Python ecosystem.
+
+---
+
+## Resources
+
+- **Source Code**: [github.com/arclaav/natumpy](https://github.com/arclaav/natumpy)
+- **Official Documentation**: [natumpy-docs.defacer.dedyn.io](http://natumpy-docs.defacer.dedyn.io)
+
+---
+
+## Key Features
+
+* **High-Performance Core**: The simulation logic is implemented entirely in C++17 (`natcore`), utilizing optimized memory structures and loop unrolling where applicable.
+* **Zero-Copy NumPy Integration**: Implements the Python Buffer Protocol. The internal state of the C++ engine is directly accessible as a NumPy structured array (`float64`).
+* **Thread Safety & Concurrency**: Critical sections are protected by `std::mutex`. Computationally intensive methods (e.g., `step`) release the Python Global Interpreter Lock (GIL), allowing for true multi-threaded execution.
+* **Robust Physics Engine**: Built-in support for damping, target-seeking behavior, and coupled resonance dynamics.
+>>>>>>> 2ab1e845db617a91ec8da8e83bf2d6945013c182
+
+---
+
+## Installation
+
+### Prerequisites
+<<<<<<< HEAD
+* Python 3.8+
+* C++17 Compliant Compiler (GCC, Clang, MSVC)
+* NumPy $\ge$ 1.20.0
+
+### Build from Source
+=======
+* Python 3.8 or higher
+* A C++17 compliant compiler (GCC, Clang, or MSVC)
+* NumPy $\ge$ 1.20.0
+
+### Building from Source
+
+To install the latest version directly from the repository:
+
+>>>>>>> 2ab1e845db617a91ec8da8e83bf2d6945013c182
+```
+git clone https://github.com/arclaav/natumpy.git
+cd natumpy
+pip install .
+```
+<<<<<<< HEAD
+
+# Usage Guide
+1. Initialization & Memory View
+Nawa exposes its internal C++ memory directly to Python via the Buffer Protocol. Zero-Copy.
+=======
+For development environments (editable install):
+```
+pip install -e .
+```
+
+## Usage Guide
+1. Initialization and Data Views
+Initialize a field engine and access its memory directly via NumPy.
+>>>>>>> 2ab1e845db617a91ec8da8e83bf2d6945013c182
+```
+import natumpy
+import numpy as np
+
+<<<<<<< HEAD
+# Initialize the Nawa Engine with 1,000 nodes
+# This allocates aligned memory for Real/Imaginary states
+engine = natumpy.NawaEngine(1000)
+
+# Access the raw memory views (Modifying these updates the C++ engine instantly)
+# q_r = Position (Real), q_i = Position (Imaginary/Phase)
+q_real = engine.q_r
+q_imag = engine.q_i
+
+# Initialize a specific state (e.g., Node 0)
+# Set Magnitude to 1.0, Phase to 0.0
+q_real[0] = 1.0
+q_imag[0] = 0.0
+
+2. Wiring the Topology
+Connect nodes to create logic gates or resonant pathways.
+# connect(source, destination, weight, type)
+# Type 0: Standard Coupling (Spring-like)
+# Type 2: Phase Coupling (Resonance-only)
+
+# Connect Node 0 to Node 1 with Phase Resonance
+engine.connect(0, 1, weight=0.5, type=2)
+
+3. Running the Dynamics
+Advance the Hamiltonian system.
+# Run 100 physics cycles
+engine.step(100)
+
+# Observe the result
+## Did the signal propagate? Did the phase shift?
+print(f"Node 1 State: {q_real[1]:.4f} + {q_imag[1]:.4f}j")
+```
+
+# Stability & Unitary Constraints
+Because Nawa operates on continuous physics, numerical drift (floating-point errors) is a reality. The engine includes a mechanism to mitigate this:
+Unitary Constraint (enforce_unitary_constraints):
+If enabled, the engine normalizes the magnitude of the complex vector at each step (|z| \to 1.0), ensuring that information is stored purely in the Phase. This prevents "exploding gradients" or signal decay in long-running simulations.
+# API Reference
+natumpy.NawaEngine(size: int)
+Creates a new simulation context.
+Methods
+| Method | Description |
+|---|---|
+| step(cycles: int) | Advances the symplectic integrator. Releases GIL for threading. |
+| connect(u, v, w, type) | Creates a directed edge from node u to v. |
+| set_node_state(...) | Atomic setter for q_r, q_i, p_r, p_i. |
+| enforce_unitary_constraints() | Manually triggers normalization to fix numerical drift. |
+Properties (NumPy Arrays)
+| Property | Type | Physics Meaning |
+|---|---|---|
+| q_r | float64[] | Generalized Coordinate (Real Part) |
+| q_i | float64[] | Generalized Coordinate (Imaginary Part) |
+| p_r | float64[] | Conjugate Momentum (Real Part) |
+| p_i | float64[] | Conjugate Momentum (Imaginary Part) |
+| mass | float64[] | Inertial Coefficient |
+ng | float64 | Damping factor (0.0 - 1.0). |
+=======
+# Initialize a field with 1,000,000 atoms
+field = natumpy.create_field(1_000_000)
+
+# Create a zero-copy view of the data
+# Modifying 'data' instantly updates the C++ engine state
+data = natumpy.view(field)
+
+# Access specific properties (Structured Array)
+# Fields: 'value', 'velocity', 'mass', 'damping', 'target'
+print(f"Initial Mass: {data['mass'][0]}")
+
+2. Configuring Physics Properties
+You can modify atom properties using vector operations (via NumPy) or atomic operations (via the C++ API).
+# Bulk update via NumPy (Fastest for large updates)
+data['mass'][:] = 2.5
+data['damping'][:] = 0.05
+
+# Atomic update via C++ API (Thread-safe)
+# Syntax: set_props(field, index, mass, damping)
+natumpy.NatField.set_props(field, 0, 5.0, 0.1)
+
+# Set a target value for an atom to seek
+natumpy.NatField.set_target(field, 0, 100.0)
+
+3. Running the Simulation
+The step function advances the physics engine. This operation releases the GIL, making it suitable for background threads.
+# Run 100 physics cycles with a delta-time (dt) of 0.01
+natumpy.NatField.step(field, cycles=100, dt=0.01)
+
+# Check the new state
+print(f"New Value: {data['value'][0]}")
+
+4. Advanced Dynamics: Resonance
+Couple two atoms together to simulate force transfer or resonance.
+# Couple atom at index 0 and atom at index 1 with coupling strength 0.5
+natumpy.NatField.resonate(field, 0, 1, 0.5)
+```
+
+## API Reference
+natumpy.NatField Methods
+| Method | Signature | Description |
+|---|---|---|
+| set_props | (index: int, mass: float, damping: float) | Sets physical properties for a specific atom. |
+| set_target | (index: int, target: float) | Sets the target value an atom attracts towards. |
+| step | (cycles: int, dt: float) | Advances the simulation. Releases GIL. |
+| resonate | (idx_a: int, idx_b: int, strength: float) | Applies interaction force between two atoms. |
+| force | (index: int, value: float) | Hard-resets an atom's value and clears velocity. |
+| size | () | Returns the number of atoms in the field. |
+Data Structure (NAT_DTYPE)
+The NumPy view exposes the following structured data type:
+| Field | Type | Description |
+|---|---|---|
+| value | float64 | Current position/value of the atom. |
+| velocity | float64 | Current rate of change. |
+| mass | float64 | Mass coefficient (affects inertia). |
+| damping | float64 | Damping factor (0.0 - 1.0). |
+>>>>>>> 2ab1e845db617a91ec8da8e83bf2d6945013c182
+| target | float64 | The equilibrium point for the atom. |

natumpy-4.0.1/natumpy/__init__.py

@@ -0,0 +1,13 @@
+import numpy as np
+from . import natcore
+
+NawaEngine = natcore.NawaEngine
+
+def create_engine(size):
+    return NawaEngine(int(size))
+
+def get_state_complex(engine):
+    real = engine.q_r
+    imag = engine.q_i
+    return real + 1j * imag
+

natumpy-4.0.1/natumpy/nat_bindings.cpp

@@ -0,0 +1,127 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include "nat_engine.hpp"
+
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include <numpy/arrayobject.h>
+
+typedef struct {
+    PyObject_HEAD
+    NawaEngine* engine;
+} PyNawa;
+
+static void PyNawa_dealloc(PyNawa* self) {
+    if (self->engine) {
+        delete self->engine;
+    }
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static PyObject* PyNawa_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
+    PyNawa* self;
+    self = (PyNawa*)type->tp_alloc(type, 0);
+    if (self != NULL) {
+        int size = 100;
+        if (!PyArg_ParseTuple(args, "|i", &size)) {
+            Py_DECREF(self);
+            return NULL;
+        }
+        self->engine = new NawaEngine((size_t)size);
+    }
+    return (PyObject*)self;
+}
+
+static PyObject* PyNawa_step(PyNawa* self, PyObject* args) {
+    int cycles;
+    if (!PyArg_ParseTuple(args, "i", &cycles)) return NULL;
+    
+    Py_BEGIN_ALLOW_THREADS
+    self->engine->step(cycles);
+    Py_END_ALLOW_THREADS
+    
+    Py_RETURN_NONE;
+}
+
+static PyObject* PyNawa_connect(PyNawa* self, PyObject* args) {
+    int u, v, type;
+    double w;
+    if (!PyArg_ParseTuple(args, "iidi", &u, &v, &w, &type)) return NULL;
+    
+    self->engine->connect(u, v, w, type);
+    Py_RETURN_NONE;
+}
+
+static PyObject* get_array_view(NawaEngine* engine, std::vector<double>& vec) {
+    npy_intp dims[1] = { (npy_intp)vec.size() };
+    return PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, vec.data());
+}
+
+static PyObject* PyNawa_get_qr(PyNawa* self, void* closure) {
+    return get_array_view(self->engine, self->engine->state.q_r);
+}
+
+static PyObject* PyNawa_get_qi(PyNawa* self, void* closure) {
+    return get_array_view(self->engine, self->engine->state.q_i);
+}
+
+static PyObject* PyNawa_get_pr(PyNawa* self, void* closure) {
+    return get_array_view(self->engine, self->engine->state.p_r);
+}
+
+static PyObject* PyNawa_get_pi(PyNawa* self, void* closure) {
+    return get_array_view(self->engine, self->engine->state.p_i);
+}
+
+static PyMethodDef PyNawa_methods[] = {
+    {"step", (PyCFunction)PyNawa_step, METH_VARARGS, ""},
+    {"connect", (PyCFunction)PyNawa_connect, METH_VARARGS, ""},
+    {NULL}
+};
+
+static PyGetSetDef PyNawa_getset[] = {
+    {"q_r", (getter)PyNawa_get_qr, NULL, "", NULL},
+    {"q_i", (getter)PyNawa_get_qi, NULL, "", NULL},
+    {"p_r", (getter)PyNawa_get_pr, NULL, "", NULL},
+    {"p_i", (getter)PyNawa_get_pi, NULL, "", NULL},
+    {NULL}
+};
+
+static PyTypeObject PyNawaType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    .tp_name = "natcore.NawaEngine",
+    .tp_basicsize = sizeof(PyNawa),
+    .tp_itemsize = 0,
+    .tp_dealloc = (destructor)PyNawa_dealloc,
+    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+    .tp_methods = PyNawa_methods,
+    .tp_getset = PyNawa_getset,
+    .tp_new = PyNawa_new,
+};
+
+static struct PyModuleDef natcoremodule = {
+    PyModuleDef_HEAD_INIT,
+    "natcore",
+    NULL,
+    -1,
+    NULL
+};
+
+PyMODINIT_FUNC PyInit_natcore(void) {
+    import_array();
+    PyObject* m;
+    
+    if (PyType_Ready(&PyNawaType) < 0) return NULL;
+
+    m = PyModule_Create(&natcoremodule);
+    if (m == NULL) return NULL;
+
+    Py_INCREF(&PyNawaType);
+    if (PyModule_AddObject(m, "NawaEngine", (PyObject*)&PyNawaType) < 0) {
+        Py_DECREF(&PyNawaType);
+        Py_DECREF(m);
+        return NULL;
+    }
+
+    return m;
+}
+

natumpy-4.0.1/natumpy/nat_engine.cpp

@@ -0,0 +1,89 @@
+#include "nat_engine.hpp"
+
+void NawaEngine::set_node_state(int idx, Scalar qr, Scalar qi, Scalar pr, Scalar pi) {
+    if (idx >= 0 && idx < (int)state.size) {
+        state.q_r[idx] = qr;
+        state.q_i[idx] = qi;
+        state.p_r[idx] = pr;
+        state.p_i[idx] = pi;
+    }
+}
+
+void NawaEngine::connect(int src, int dst, Scalar weight, int type) {
+    if (src >= 0 && src < (int)state.size && dst >= 0 && dst < (int)state.size) {
+        topology.add_connection(src, dst, weight, type);
+    }
+}
+
+void NawaEngine::enforce_unitary_constraints() {
+    for (size_t i = 0; i < state.size; ++i) {
+        Scalar mag_sq = state.q_r[i] * state.q_r[i] + state.q_i[i] * state.q_i[i];
+        if (mag_sq > 1.0) {
+            Scalar scale = 1.0 / std::sqrt(mag_sq);
+            state.q_r[i] *= scale;
+            state.q_i[i] *= scale;
+            state.p_r[i] *= 0.5; 
+            state.p_i[i] *= 0.5;
+        }
+    }
+}
+
+void NawaEngine::compute_forces(std::vector<Scalar>& force_r, std::vector<Scalar>& force_i) {
+    std::fill(force_r.begin(), force_r.end(), 0.0);
+    std::fill(force_i.begin(), force_i.end(), 0.0);
+
+    for (const auto& edge : topology.edges) {
+        int u = edge.src_idx;
+        int v = edge.dst_idx;
+        Scalar w = edge.weight;
+
+        Scalar dr = state.q_r[v] - state.q_r[u];
+        Scalar di = state.q_i[v] - state.q_i[u];
+
+        if (edge.type == 2) { 
+            Scalar dot = state.q_r[u] * state.q_r[v] + state.q_i[u] * state.q_i[v];
+            Scalar phase_force = (1.0 - dot) * config.phase_coupling;
+            
+            force_r[u] += phase_force * state.q_r[v];
+            force_i[u] += phase_force * state.q_i[v];
+            force_r[v] -= phase_force * state.q_r[u];
+            force_i[v] -= phase_force * state.q_i[u];
+        } else {
+            force_r[u] += w * dr;
+            force_i[u] += w * di;
+            
+            force_r[v] -= w * dr;
+            force_i[v] -= w * di;
+        }
+    }
+}
+
+void NawaEngine::step(int cycles) {
+    size_t n = state.size;
+    std::vector<Scalar> fr(n, 0.0);
+    std::vector<Scalar> fi(n, 0.0);
+    Scalar dt = config.dt;
+    Scalar damping_factor = 1.0 - config.global_damping;
+
+    for (int k = 0; k < cycles; ++k) {
+        compute_forces(fr, fi);
+
+        for (size_t i = 0; i < n; ++i) {
+            Scalar inv_m = 1.0 / state.mass[i];
+
+            state.p_r[i] += fr[i] * dt;
+            state.p_i[i] += fi[i] * dt;
+
+            state.p_r[i] *= damping_factor;
+            state.p_i[i] *= damping_factor;
+
+            state.q_r[i] += (state.p_r[i] * inv_m) * dt;
+            state.q_i[i] += (state.p_i[i] * inv_m) * dt;
+        }
+
+        if (config.normalize_phase) {
+            enforce_unitary_constraints();
+        }
+    }
+}
+

natumpy-4.0.1/natumpy/nat_engine.hpp

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <vector>
+#include <cmath>
+#include <complex>
+#include <algorithm>
+#include <iostream>
+
+using Scalar = double;
+
+struct NawaConfig {
+    Scalar dt = 0.01;
+    Scalar global_damping = 0.05;
+    Scalar phase_coupling = 0.1;
+    bool normalize_phase = true;
+};
+
+struct NawaState {
+    size_t size = 0;
+
+    std::vector<Scalar> q_r; 
+    std::vector<Scalar> q_i;
+
+    std::vector<Scalar> p_r;
+    std::vector<Scalar> p_i;
+
+    std::vector<Scalar> mass;
+
+    void resize(size_t n) {
+        size = n;
+        q_r.resize(n, 0.0); q_i.resize(n, 0.0);
+        p_r.resize(n, 0.0); p_i.resize(n, 0.0);
+        mass.resize(n, 1.0);
+    }
+};
+
+struct NawaEdge {
+    int src_idx;
+    int dst_idx;
+    Scalar weight;
+    int type;         
+};
+
+struct NawaTopology {
+    std::vector<NawaEdge> edges;
+
+    void add_connection(int u, int v, Scalar w, int t) {
+        edges.push_back({u, v, w, t});
+    }
+    
+    void clear() { edges.clear(); }
+};
+
+class NawaEngine {
+public:
+    NawaConfig config;
+    NawaState state;
+    NawaTopology topology;
+
+    NawaEngine(size_t initial_size) {
+        state.resize(initial_size);
+    }
+
+    void step(int cycles);
+
+    void set_node_state(int idx, Scalar qr, Scalar qi, Scalar pr, Scalar pi);
+    
+    void connect(int src, int dst, Scalar weight, int type);
+
+    size_t size() const { return state.size; }
+
+    void enforce_unitary_constraints();
+
+private:
+    void compute_forces(std::vector<Scalar>& force_r, std::vector<Scalar>& force_i);
+};
+

natumpy-4.0.1/natumpy.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: natumpy
+Version: 4.0.1
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python

natumpy-4.0.1/natumpy.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+natumpy/__init__.py
+natumpy/nat_bindings.cpp
+natumpy/nat_engine.cpp
+natumpy/nat_engine.hpp
+natumpy.egg-info/PKG-INFO
+natumpy.egg-info/SOURCES.txt
+natumpy.egg-info/dependency_links.txt
+natumpy.egg-info/requires.txt
+natumpy.egg-info/top_level.txt

natumpy-4.0.1/natumpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

natumpy-4.0.1/natumpy.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.20.0

natumpy-4.0.1/natumpy.egg-info/top_level.txt

@@ -0,0 +1 @@
+natumpy

natumpy-4.0.1/pyproject.toml

@@ -0,0 +1,4 @@
+[build-system]
+requires = ["setuptools>=42", "wheel", "numpy>=1.20.0"]
+build-backend = "setuptools.build_meta"
+

natumpy-4.0.1/setup.cfg

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

natumpy-4.0.1/setup.py

@@ -0,0 +1,34 @@
+from setuptools import setup, Extension, find_packages
+import sys
+
+try:
+    import numpy
+    np_include = [numpy.get_include()]
+except ImportError:
+    np_include = []
+
+extra_compile_args = ['-std=c++17', '-O3', '-Wall']
+
+if sys.platform == 'darwin':
+    extra_compile_args.append('-stdlib=libc++')
+
+module = Extension(
+    'natumpy.natcore',
+    sources=[
+        'natumpy/nat_bindings.cpp',
+        'natumpy/nat_engine.cpp'
+    ],
+    depends=['natumpy/nat_engine.hpp'],
+    include_dirs=np_include,
+    extra_compile_args=extra_compile_args,
+    language='c++'
+)
+
+setup(
+    name='natumpy',
+    version='4.0.1',
+    packages=find_packages(),
+    ext_modules=[module],
+    python_requires='>=3.8',
+    install_requires=['numpy>=1.20.0'],
+)