Fix two double-buffer bugs in CTRNN advance method

Bug 1: The exponential Euler update applied decay to ovalues (the stale
buffer from two steps ago) instead of ivalues (the current state). Each
buffer was only updated every other step, so the decay term used state
from two timesteps ago rather than one.

Fix: decay * ivalues[node_key] instead of decay * ovalues[node_key]

Bug 2: The return statement read from values[1 - self.active], which
is the pre-update buffer (ivalues), not the just-written buffer
(ovalues). This returned output lagging one step behind the actual
state.

Fix: return values[self.active] (the buffer that was last written to)

Both bugs existed in the original forward Euler code and were carried
over in the exponential Euler conversion. They were found by the GPU
numerical equivalence tests, which use single-buffer in-place updates
and thus don't have the double-buffer issue.

Also fix test_response_parameter_effect to use small inputs/weights
that avoid tanh saturation, which was masking the response difference.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: CodeReclaimers

neat/ctrnn/__init__.py

@@ -80,11 +80,11 @@ def advance(self, inputs, advance_time, time_step=None):
                 s = ne.aggregation(node_inputs)
                 z = ne.activation(ne.bias + ne.response * s)
                 decay = math.exp(-dt / ne.time_constant)
-                ovalues[node_key] = decay * ovalues[node_key] + (1.0 - decay) * z
+                ovalues[node_key] = decay * ivalues[node_key] + (1.0 - decay) * z
 
             self.time_seconds += dt
 
-        ovalues = self.values[1 - self.active]
+        ovalues = self.values[self.active]
         return [ovalues[i] for i in self.output_nodes]
 
     @staticmethod

tests/test_ctrnn.py

@@ -52,11 +52,11 @@ def test_basic_two_neuron_dynamics():
     # the linear decay term exactly: u(t+h) = decay*u(t) + (1-decay)*z
     # where decay = exp(-h/tau).
     reference = {
-        0: (0.0, 0.0),
-        100: (0.3087387628, 0.7906422519),
-        500: (0.7965631789, 0.4505240611),
-        1149: (0.4952237403, 0.1974657233),
-        1249: (0.2539079366, 0.7016150055),
+        0: (0.0108918618, 0.0268364041),
+        100: (0.8036336977, 0.6300463990),
+        500: (0.2062530810, 0.3471592629),
+        1149: (0.1922239059, 0.4050205901),
+        1249: (0.7685324686, 0.3325289787),
     }
     tol = 1e-6
     for idx, (exp0, exp1) in reference.items():

tests/test_gpu.py

@@ -476,13 +476,17 @@ def test_response_parameter_effect(self):
         from neat.gpu._cupy_backend import evaluate_ctrnn_batch
 
         config = _make_ctrnn_config()
-        g1 = _make_simple_ctrnn_genome(config, genome_id=1, response=1.0)
-        g2 = _make_simple_ctrnn_genome(config, genome_id=2, response=3.0)
+        # Use small weights and inputs to avoid tanh saturation, which would
+        # mask the effect of different response values.
+        g1 = _make_simple_ctrnn_genome(config, genome_id=1, response=0.5,
+                                        w_in1=0.3, w_in2=0.1, bias=0.0)
+        g2 = _make_simple_ctrnn_genome(config, genome_id=2, response=3.0,
+                                        w_in1=0.3, w_in2=0.1, bias=0.0)
         genomes = [(1, g1), (2, g2)]
 
         dt = 0.005
         num_steps = 50
-        inputs_np = np.tile(np.array([1.0, 0.5], dtype=np.float32),
+        inputs_np = np.tile(np.array([0.2, 0.1], dtype=np.float32),
                             (num_steps, 1))
 
         packed = pack_ctrnn_population(genomes, config)