evonet 0.1.0.dev24__tar.gz → 0.1.0.dev26__tar.gz

{evonet-0.1.0.dev24 → evonet-0.1.0.dev26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evonet
-Version: 0.1.0.dev24
+Version: 0.1.0.dev26
 Summary: Evolvable neural network core for integration with EvoLib
 Author-email: EvoLib <evolib@dismail.de>
 License: MIT License
@@ -50,30 +50,54 @@ Requires-Dist: myst-parser; extra == "docs"
 Dynamic: license-file
 
 # EvoNet
+
 [![Code Quality & Tests](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml/badge.svg)](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Project Status: Alpha](https://img.shields.io/badge/status-alpha-orange.svg)](https://github.com/EvoLib/evo-net)
 
-**EvoNet** is a modular and evolvable neural network core designed for integration with [EvoLib](https://github.com/EvoLib/evo-lib).
-It supports dynamic topologies, recurrent connections, per-neuron activation, and structural evolution – with a strong emphasis on **clarity**, **transparency**, and **didactic value**.
+**EvoNet** is a modular and evolvable neural network core designed for integration
+with [EvoLib](https://github.com/EvoLib/evo-lib).  
+It supports dynamic topologies, recurrent connections, per-neuron activation, and
+structural evolution, with a strong emphasis on clarity and explicit behaviour.
+
+---
+
+## Scope
+
+EvoNet is not a state-of-the-art or general-purpose deep learning framework.
+
+It does not aim to compete with libraries such as PyTorch, TensorFlow, or JAX in terms
+of performance, scalability, or training algorithms. Backpropagation, GPU acceleration,
+and highly optimised tensor operations are outside the scope of this project.
+
+Instead, EvoNet is designed for evolutionary algorithms, structural mutation, and
+exploratory research, with a focus on transparent and explicit implementations rather
+than performance optimisation or feature completeness.
+
+EvoNet should be understood as a conceptual and experimental model, not as a
+production-grade neural-network engine.
 
 ---
 
 ## Features
 
-- **Layer-based but flexible** – allows skip connections, cycles, and recurrent paths
+- **Explicit, layer-based topology** with support for skip connections, cycles,
+  and recurrent paths
 - **Typed neuron roles and connection types** (`NeuronRole`, `ConnectionType`)
-- **Topology-aware mutation system** – add/remove neurons and connections, mutate weights, change activations
-- **Per-neuron activation functions** – configurable, extensible, evolvable
-- **1-step recurrent state logic** – avoids multi-pass stabilization
-- **Topology can grow at runtime** – with `add_neuron`, `add_connection`, `split_connection`
-- **Debug-friendly architecture** – explicit IDs, labels, roles, directional graphs
-- **Designed for evolutionary learning** – mutation, crossover, speciation ready
-- **Lightweight & extensible** – pure Python, NumPy-based, no hard dependencies
+- **Topology-aware mutation operations**:
+  add/remove neurons and connections, mutate weights, change activations
+- **Per-neuron activation functions**, configurable and evolvable
+- **Explicit 1-step recurrent state model**, without iterative stabilisation passes
+- **Runtime topology growth**, e.g. via `add_neuron` and `add_connection`
+- **Debug-friendly architecture** with explicit neuron IDs, labels, roles,
+  and directional graphs
+- **Designed for evolutionary integration**, not gradient-based training
+- **Lightweight and extensible**: pure Python, NumPy-based, no hard dependencies
 
 ---
 
-> ⚠️ **This project is in early development (alpha)**. Interfaces and structure may change.
+> ⚠️ **Project status: Alpha**  
+> Interfaces, APIs, and internal structure may change as the project evolves.
 
 ---
 
@@ -83,14 +107,15 @@ It supports dynamic topologies, recurrent connections, per-neuron activation, an
 from evonet.core import Nnet
 
 net = Nnet()
-net.add_layer()  # Input
-net.add_layer()  # Output
+net.add_layer()  # Input layer
+net.add_layer()  # Output layer
 
-net.add_neuron(layer_idx=0, activation="linear", lable="in")
-net.add_neuron(layer_idx=1, activation="linear", bias=0.5, lable="out", connect_layer=True)
+net.add_neuron(layer_idx=0, activation="linear", label="in")
+net.add_neuron(layer_idx=1, activation="linear", bias=0.5, label="out")
 
 print(net.calc([1.0]))
 ```
+---
 
 ## License
 

evonet-0.1.0.dev26/README.md

@@ -0,0 +1,72 @@
+# EvoNet
+
+[![Code Quality & Tests](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml/badge.svg)](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Project Status: Alpha](https://img.shields.io/badge/status-alpha-orange.svg)](https://github.com/EvoLib/evo-net)
+
+**EvoNet** is a modular and evolvable neural network core designed for integration
+with [EvoLib](https://github.com/EvoLib/evo-lib).  
+It supports dynamic topologies, recurrent connections, per-neuron activation, and
+structural evolution, with a strong emphasis on clarity and explicit behaviour.
+
+---
+
+## Scope
+
+EvoNet is not a state-of-the-art or general-purpose deep learning framework.
+
+It does not aim to compete with libraries such as PyTorch, TensorFlow, or JAX in terms
+of performance, scalability, or training algorithms. Backpropagation, GPU acceleration,
+and highly optimised tensor operations are outside the scope of this project.
+
+Instead, EvoNet is designed for evolutionary algorithms, structural mutation, and
+exploratory research, with a focus on transparent and explicit implementations rather
+than performance optimisation or feature completeness.
+
+EvoNet should be understood as a conceptual and experimental model, not as a
+production-grade neural-network engine.
+
+---
+
+## Features
+
+- **Explicit, layer-based topology** with support for skip connections, cycles,
+  and recurrent paths
+- **Typed neuron roles and connection types** (`NeuronRole`, `ConnectionType`)
+- **Topology-aware mutation operations**:
+  add/remove neurons and connections, mutate weights, change activations
+- **Per-neuron activation functions**, configurable and evolvable
+- **Explicit 1-step recurrent state model**, without iterative stabilisation passes
+- **Runtime topology growth**, e.g. via `add_neuron` and `add_connection`
+- **Debug-friendly architecture** with explicit neuron IDs, labels, roles,
+  and directional graphs
+- **Designed for evolutionary integration**, not gradient-based training
+- **Lightweight and extensible**: pure Python, NumPy-based, no hard dependencies
+
+---
+
+> ⚠️ **Project status: Alpha**  
+> Interfaces, APIs, and internal structure may change as the project evolves.
+
+---
+
+## Quick Example
+
+```python
+from evonet.core import Nnet
+
+net = Nnet()
+net.add_layer()  # Input layer
+net.add_layer()  # Output layer
+
+net.add_neuron(layer_idx=0, activation="linear", label="in")
+net.add_neuron(layer_idx=1, activation="linear", bias=0.5, label="out")
+
+print(net.calc([1.0]))
+```
+---
+
+## License
+
+MIT License - see [MIT License](https://github.com/EvoLib/evo-net/tree/main/LICENSE).
+

{evonet-0.1.0.dev24 → evonet-0.1.0.dev26}/evonet/connection.py

@@ -8,7 +8,8 @@ recurrent).
 """
 
 
-from typing import TYPE_CHECKING
+from collections import deque
+from typing import TYPE_CHECKING, Deque, Optional
 
 from evonet.enums import ConnectionType
 
@@ -24,9 +25,8 @@ class Connection:
         source (Neuron): The source neuron (presynaptic).
         target (Neuron): The target neuron (postsynaptic).
         weight (float): Multiplicative weight of the transmitted signal.
-        delay (int): Optional delay in time steps (not yet implemented).
-        type (ConnectionType): Type of connection (e.g. standard, recurrent,
-                               inhibitory).
+        delay (int): Delay in discrete time steps (used for recurrent edges).
+        type (ConnectionType): Type of connection (e.g. standard, recurrent).
     """
 
     def __init__(
@@ -44,6 +44,47 @@ class Connection:
         self.delay = delay
         self.type: ConnectionType = conn_type
 
+        self._history: Optional[Deque[float]] = None
+        if self.delay > 0:
+            self._history = deque(maxlen=self.delay)
+
+        if self.delay < 0:
+            raise ValueError("delay must be >= 0")
+
+    def push_source_output(self, value: float) -> None:
+        """
+        Push the current source output into the delay buffer.
+
+        This should be called once per time step after the network computed outputs.
+        """
+        if self._history is None:
+            return
+        self._history.append(float(value))
+
+    def delayed_source_output(self) -> float:
+        """
+        Return the delayed source output.
+
+        Semantics:
+            - delay == 0  -> no delay buffer used (caller decides what to do)
+            - delay > 0   -> returns output[t-delay] if available else 0.0
+        """
+        if self.delay == 0:
+            return 0.0
+
+        if self._history is None:
+            return 0.0
+
+        if len(self._history) < self.delay:
+            return 0.0
+
+        return float(self._history[0])
+
+    def reset_buffer(self) -> None:
+        """Clear the internal delay history buffer."""
+        if self._history is not None:
+            self._history.clear()
+
     def get_signal(self) -> float:
         """
         Return the weighted signal from the source neuron.
@@ -59,12 +100,13 @@ class Connection:
         Return a concise string representation of the connection.
 
         Example:
-            <Conn abc123 -> def456 w=0.85 type=standard>
+            <Conn abc123 -> def456 w=0.85 d=3 type=standard>
         """
 
         type_str = self.type.name.lower()
         return (
             f"<Conn {self.source.id[:6]} "
             f"-> {self.target.id[:6]} "
+            f"d={self.delay} "
             f"w={self.weight:.2f} type={type_str}>"
         )

{evonet-0.1.0.dev24 → evonet-0.1.0.dev26}/evonet/core.py

@@ -117,6 +117,8 @@ class Nnet:
         label: str = "",
         role: NeuronRole = NeuronRole.HIDDEN,
         count: int = 1,
+        dynamics_name: str = "standard",
+        dynamics_params: dict[str, float] | None = None,
         connection_init: Literal["random", "zero", "near_zero", "none"] = "zero",
         recurrent: Optional[set[RecurrentKind]] = None,
         connection_scope: Literal["adjacent", "crosslayer"] = "adjacent",
@@ -176,6 +178,10 @@ class Nnet:
             neuron = Neuron(activation=activation, bias=bias)
             neuron.role = role
             neuron.label = label
+
+            neuron.dynamics_name = dynamics_name
+            neuron.dynamics_params = dict(dynamics_params) if dynamics_params else {}
+
             target_layer.neurons.append(neuron)
             new_neurons.append(neuron)
 
@@ -312,7 +318,7 @@ class Nnet:
             # --------------------------------------------------------------
             # Create connections
             # --------------------------------------------------------------
-            for src, dst, ctype in forced + sampled:
+            for src, dst, ctype in sampled:
                 self.add_connection(src, dst, weight=weight, conn_type=ctype)
 
         return new_neurons
@@ -323,6 +329,7 @@ class Nnet:
         target: Neuron,
         weight: float | None = None,
         conn_type: ConnectionType = ConnectionType.STANDARD,
+        delay: int = 0,
     ) -> Connection | None:
         """
         Create a directed connection between two neurons.
@@ -332,6 +339,7 @@ class Nnet:
             target (Neuron): Target neuron.
             weight (float | None): Initial weight. If None, 0.0 is used.
             conn_type (ConnectionType): Type of connection (e.g. standard, recurrent).
+            delay (int): Delay in discrete time steps.
 
         Returns:
             Connection: Added Connection.
@@ -343,7 +351,9 @@ class Nnet:
         if weight is None:
             weight = 0.0
 
-        conn = Connection(source, target, weight=weight, conn_type=conn_type)
+        conn = Connection(
+            source, target, weight=weight, conn_type=conn_type, delay=delay
+        )
         source.outgoing.append(conn)
         target.incoming.append(conn)
 
@@ -355,6 +365,11 @@ class Nnet:
             for neuron in layer.neurons:
                 neuron.reset(full=full)
 
+        if full:
+            # Clear delayed history buffers on connections.
+            for conn in self.get_all_connections():
+                conn.reset_buffer()
+
     def calc(self, input_values: list[float]) -> list[float]:
         """
         Perform a forward pass through the network.
@@ -387,7 +402,12 @@ class Nnet:
             for n in layer.neurons:
                 for c in n.incoming:
                     if c.type is ConnectionType.RECURRENT:
-                        c.target.input += c.weight * c.source.last_output
+                        if c.delay > 0:
+                            # Use delayed history if configured
+                            n.input += c.weight * c.delayed_source_output()
+                        else:
+                            # default: 1-step recurrence via last_output
+                            n.input += c.weight * c.source.last_output
 
         # Feed-forward by layers: activate first, then propagate non-recurrent edges
         for layer in self.layers:
@@ -412,7 +432,7 @@ class Nnet:
             for n in layer.neurons:
                 if n.activation_name != "softmax":
                     total = n.input + n.bias
-                    n.output = n.activation(total)
+                    n.output = n.compute_output(total)
 
             # Propagate to targets (exclude recurrent edges)
             for n in layer.neurons:
@@ -420,6 +440,11 @@ class Nnet:
                     if c.type is not ConnectionType.RECURRENT:
                         c.target.input += c.weight * n.output
 
+        # Update recurrent delay buffers once per time step.
+        for c in self.get_all_connections():
+            if c.type is ConnectionType.RECURRENT and c.delay > 0:
+                c.push_source_output(c.source.output)
+
         return [n.output for n in self.layers[-1].neurons]
 
     def get_all_neurons(self) -> list[Neuron]:

{evonet-0.1.0.dev24 → evonet-0.1.0.dev26}/evonet/mutation.py

@@ -273,6 +273,8 @@ def add_random_neuron(
     connection_scope: Literal["adjacent", "crosslayer"] = "adjacent",
     connection_density: float = 1.0,
     max_connections: int = 2**63 - 1,
+    dynamics_name: str = "standard",
+    dynamics_params: dict[str, float] = {},
 ) -> Neuron | None:
     """
     Insert a new hidden neuron into a random layer.
@@ -298,6 +300,9 @@ def add_random_neuron(
     if len(net.layers) == 2:
         net.insert_layer(1)
 
+    if dynamics_params is None:
+        dynamics_params = {}
+
     # Choose target layer (not input, not output)
     candidate_layers = net.layers[1:-1]
     if not candidate_layers:
@@ -313,6 +318,8 @@ def add_random_neuron(
         connection_scope=connection_scope,
         connection_density=connection_density,
         max_connections=max_connections,
+        dynamics_name=dynamics_name,
+        dynamics_params=dynamics_params,
     )[0]
 
     return new_neuron

{evonet-0.1.0.dev24 → evonet-0.1.0.dev26}/evonet/neuron.py

@@ -55,6 +55,41 @@ class Neuron:
         self.last_output: float = 0.0
         self.label = label
 
+        # Neuron dynamics (stateful behaviour over time)
+        self.dynamics_name: str = "standard"
+        self.dynamics_params: dict[str, float] = {}
+
+    def compute_output(self, total_input: float) -> float:
+        """
+        Compute the neuron's output given the total input.
+
+        This method defines the neuron's local output dynamics and serves as the single
+        extension point for experimental neuron behaviour (e.g. leaky integration,
+        gating, oscillators).
+
+        By default, this applies the activation function directly.
+        """
+
+        # Default / standard dynamics
+        if self.dynamics_name == "standard":
+            return self.activation(total_input)
+
+        # Leaky integrator dynamics
+        if self.dynamics_name == "leaky":
+            alpha = self.dynamics_params.get("alpha", 1.0)
+
+            # Safety: keep alpha in [0, 1]
+            if alpha < 0.0:
+                alpha = 0.0
+            elif alpha > 1.0:
+                alpha = 1.0
+
+            raw = self.activation(total_input)
+            return (1.0 - alpha) * self.last_output + alpha * raw
+
+        # Fallback: unknown dynamics --> behave like standard
+        return self.activation(total_input)
+
     def reset(self, full: bool = False) -> None:
         """
         Clear current neuron state for a new forward pass.

{evonet-0.1.0.dev24 → evonet-0.1.0.dev26}/evonet/serialization.py

@@ -49,12 +49,15 @@ def to_dict(net: Nnet) -> dict[str, Any]:
                         "bias": n.bias,
                         "role": n.role.name,
                         "label": n.label,
+                        "dynamics_name": n.dynamics_name,
+                        "dynamics_params": n.dynamics_params,
                         "incoming": [
                             {
                                 "source": c.source.id,
                                 "target": c.target.id,
                                 "weight": c.weight,
                                 "type": c.type.name,  # store enum as string
+                                "delay": c.delay,
                             }
                             for c in n.incoming
                         ],
@@ -81,6 +84,8 @@ def from_dict(data: dict[str, Any]) -> Nnet:
                 bias=n_info["bias"],
                 role=NeuronRole[n_info["role"]],
                 label=n_info.get("label", ""),
+                dynamics_name=n_info.get("dynamics_name", "standard"),
+                dynamics_params=n_info.get("dynamics_params", {}),
                 connection_init="none",
             )[0]
             n.id = n_info["id"]
@@ -92,11 +97,15 @@ def from_dict(data: dict[str, Any]) -> Nnet:
             for c_info in n_info["incoming"]:
                 src = neuron_map[c_info["source"]]
                 dst = neuron_map[c_info["target"]]
+                delay = int(c_info.get("delay", 0))
+                conn_type = ConnectionType[c_info["type"]]
+
                 net.add_connection(
                     src,
                     dst,
                     weight=c_info["weight"],
-                    conn_type=ConnectionType[c_info["type"]],
+                    conn_type=conn_type,
+                    delay=delay,
                 )
 
     return net

{evonet-0.1.0.dev24 → evonet-0.1.0.dev26}/evonet.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evonet
-Version: 0.1.0.dev24
+Version: 0.1.0.dev26
 Summary: Evolvable neural network core for integration with EvoLib
 Author-email: EvoLib <evolib@dismail.de>
 License: MIT License
@@ -50,30 +50,54 @@ Requires-Dist: myst-parser; extra == "docs"
 Dynamic: license-file
 
 # EvoNet
+
 [![Code Quality & Tests](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml/badge.svg)](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Project Status: Alpha](https://img.shields.io/badge/status-alpha-orange.svg)](https://github.com/EvoLib/evo-net)
 
-**EvoNet** is a modular and evolvable neural network core designed for integration with [EvoLib](https://github.com/EvoLib/evo-lib).
-It supports dynamic topologies, recurrent connections, per-neuron activation, and structural evolution – with a strong emphasis on **clarity**, **transparency**, and **didactic value**.
+**EvoNet** is a modular and evolvable neural network core designed for integration
+with [EvoLib](https://github.com/EvoLib/evo-lib).  
+It supports dynamic topologies, recurrent connections, per-neuron activation, and
+structural evolution, with a strong emphasis on clarity and explicit behaviour.
+
+---
+
+## Scope
+
+EvoNet is not a state-of-the-art or general-purpose deep learning framework.
+
+It does not aim to compete with libraries such as PyTorch, TensorFlow, or JAX in terms
+of performance, scalability, or training algorithms. Backpropagation, GPU acceleration,
+and highly optimised tensor operations are outside the scope of this project.
+
+Instead, EvoNet is designed for evolutionary algorithms, structural mutation, and
+exploratory research, with a focus on transparent and explicit implementations rather
+than performance optimisation or feature completeness.
+
+EvoNet should be understood as a conceptual and experimental model, not as a
+production-grade neural-network engine.
 
 ---
 
 ## Features
 
-- **Layer-based but flexible** – allows skip connections, cycles, and recurrent paths
+- **Explicit, layer-based topology** with support for skip connections, cycles,
+  and recurrent paths
 - **Typed neuron roles and connection types** (`NeuronRole`, `ConnectionType`)
-- **Topology-aware mutation system** – add/remove neurons and connections, mutate weights, change activations
-- **Per-neuron activation functions** – configurable, extensible, evolvable
-- **1-step recurrent state logic** – avoids multi-pass stabilization
-- **Topology can grow at runtime** – with `add_neuron`, `add_connection`, `split_connection`
-- **Debug-friendly architecture** – explicit IDs, labels, roles, directional graphs
-- **Designed for evolutionary learning** – mutation, crossover, speciation ready
-- **Lightweight & extensible** – pure Python, NumPy-based, no hard dependencies
+- **Topology-aware mutation operations**:
+  add/remove neurons and connections, mutate weights, change activations
+- **Per-neuron activation functions**, configurable and evolvable
+- **Explicit 1-step recurrent state model**, without iterative stabilisation passes
+- **Runtime topology growth**, e.g. via `add_neuron` and `add_connection`
+- **Debug-friendly architecture** with explicit neuron IDs, labels, roles,
+  and directional graphs
+- **Designed for evolutionary integration**, not gradient-based training
+- **Lightweight and extensible**: pure Python, NumPy-based, no hard dependencies
 
 ---
 
-> ⚠️ **This project is in early development (alpha)**. Interfaces and structure may change.
+> ⚠️ **Project status: Alpha**  
+> Interfaces, APIs, and internal structure may change as the project evolves.
 
 ---
 
@@ -83,14 +107,15 @@ It supports dynamic topologies, recurrent connections, per-neuron activation, an
 from evonet.core import Nnet
 
 net = Nnet()
-net.add_layer()  # Input
-net.add_layer()  # Output
+net.add_layer()  # Input layer
+net.add_layer()  # Output layer
 
-net.add_neuron(layer_idx=0, activation="linear", lable="in")
-net.add_neuron(layer_idx=1, activation="linear", bias=0.5, lable="out", connect_layer=True)
+net.add_neuron(layer_idx=0, activation="linear", label="in")
+net.add_neuron(layer_idx=1, activation="linear", bias=0.5, label="out")
 
 print(net.calc([1.0]))
 ```
+---
 
 ## License
 

{evonet-0.1.0.dev24 → evonet-0.1.0.dev26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "evonet"
-version = "0.1.0.dev24"
+version = "0.1.0.dev26"
 description = "Evolvable neural network core for integration with EvoLib"
 authors = [
     { name = "EvoLib", email = "evolib@dismail.de" }

{evonet-0.1.0.dev24 → evonet-0.1.0.dev26}/tests/test_recurrent_dynamics.py

@@ -1,4 +1,5 @@
 import numpy as np
+import pytest
 
 from evonet.core import Nnet
 from evonet.enums import ConnectionType, NeuronRole
@@ -104,3 +105,79 @@ def test_recurrent_back_edge_output_to_hidden_linear() -> None:
         actual_outputs.append(y)
 
     assert np.allclose(actual_outputs, expected_outputs, atol=1e-12)
+
+
+def test_recurrent_delay_two_steps_linear_chain() -> None:
+    """
+    A minimal sequence test for recurrent delay buffers.
+
+    Network:
+        input -> hidden -> output
+        hidden has a recurrent self-loop with delay=2
+
+    Expected behaviour (linear activations, weights=1):
+        t0 input=1 -> hidden=1, output=1
+        t1 input=0 -> hidden=0, output=0   (delay=2 not yet filled)
+        t2 input=0 -> hidden=1, output=1   (uses hidden output from t0)
+    """
+    net = Nnet()
+    net.add_layer()  # 0 input
+    net.add_layer()  # 1 hidden
+    net.add_layer()  # 2 output
+
+    n_in = net.add_neuron(
+        layer_idx=0, activation="linear", role=NeuronRole.INPUT, connection_init="none"
+    )[0]
+    n_h = net.add_neuron(
+        layer_idx=1, activation="linear", role=NeuronRole.HIDDEN, connection_init="none"
+    )[0]
+    n_out = net.add_neuron(
+        layer_idx=2, activation="linear", role=NeuronRole.OUTPUT, connection_init="none"
+    )[0]
+
+    net.add_connection(n_in, n_h, weight=1.0, conn_type=ConnectionType.STANDARD)
+    net.add_connection(n_h, n_out, weight=1.0, conn_type=ConnectionType.STANDARD)
+
+    # Recurrent self-loop with delay=2
+    net.add_connection(
+        n_h, n_h, weight=1.0, conn_type=ConnectionType.RECURRENT, delay=2
+    )
+
+    y0 = net.calc([1.0])[0]
+    y1 = net.calc([0.0])[0]
+    y2 = net.calc([0.0])[0]
+
+    assert y0 == pytest.approx(1.0)
+    assert y1 == pytest.approx(0.0)
+    assert y2 == pytest.approx(1.0)
+
+
+def test_reset_full_clears_delay_history() -> None:
+    """Full reset must clear delay buffers, otherwise episodes leak memory."""
+    net = Nnet()
+    net.add_layer()
+    net.add_layer()
+    net.add_layer()
+
+    n_in = net.add_neuron(
+        layer_idx=0, activation="linear", role=NeuronRole.INPUT, connection_init="none"
+    )[0]
+    n_h = net.add_neuron(
+        layer_idx=1, activation="linear", role=NeuronRole.HIDDEN, connection_init="none"
+    )[0]
+    n_out = net.add_neuron(
+        layer_idx=2, activation="linear", role=NeuronRole.OUTPUT, connection_init="none"
+    )[0]
+
+    net.add_connection(n_in, n_h, weight=1.0, conn_type=ConnectionType.STANDARD)
+    net.add_connection(n_h, n_out, weight=1.0, conn_type=ConnectionType.STANDARD)
+    net.add_connection(
+        n_h, n_h, weight=1.0, conn_type=ConnectionType.RECURRENT, delay=2
+    )
+
+    _ = net.calc([1.0])[0]  # fills history partially
+    net.reset(full=True)
+
+    # After full reset, history is gone -> delay contribution must be 0.0
+    y = net.calc([0.0])[0]
+    assert y == pytest.approx(0.0)

evonet-0.1.0.dev24/README.md

@@ -1,47 +0,0 @@
-# EvoNet
-[![Code Quality & Tests](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml/badge.svg)](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml)
-[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-[![Project Status: Alpha](https://img.shields.io/badge/status-alpha-orange.svg)](https://github.com/EvoLib/evo-net)
-
-**EvoNet** is a modular and evolvable neural network core designed for integration with [EvoLib](https://github.com/EvoLib/evo-lib).
-It supports dynamic topologies, recurrent connections, per-neuron activation, and structural evolution – with a strong emphasis on **clarity**, **transparency**, and **didactic value**.
-
----
-
-## Features
-
-- **Layer-based but flexible** – allows skip connections, cycles, and recurrent paths
-- **Typed neuron roles and connection types** (`NeuronRole`, `ConnectionType`)
-- **Topology-aware mutation system** – add/remove neurons and connections, mutate weights, change activations
-- **Per-neuron activation functions** – configurable, extensible, evolvable
-- **1-step recurrent state logic** – avoids multi-pass stabilization
-- **Topology can grow at runtime** – with `add_neuron`, `add_connection`, `split_connection`
-- **Debug-friendly architecture** – explicit IDs, labels, roles, directional graphs
-- **Designed for evolutionary learning** – mutation, crossover, speciation ready
-- **Lightweight & extensible** – pure Python, NumPy-based, no hard dependencies
-
----
-
-> ⚠️ **This project is in early development (alpha)**. Interfaces and structure may change.
-
----
-
-## Quick Example
-
-```python
-from evonet.core import Nnet
-
-net = Nnet()
-net.add_layer()  # Input
-net.add_layer()  # Output
-
-net.add_neuron(layer_idx=0, activation="linear", lable="in")
-net.add_neuron(layer_idx=1, activation="linear", bias=0.5, lable="out", connect_layer=True)
-
-print(net.calc([1.0]))
-```
-
-## License
-
-MIT License - see [MIT License](https://github.com/EvoLib/evo-net/tree/main/LICENSE).
-