HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy/cythons/__init__.py

@@ -0,0 +1,24 @@
+"""This subpackage provides tools for cythonizing hydrological models as
+well as the resulting Cython extension files (in subpackage `autogen`)."""
+
+# import...
+# from standard library
+import os
+import sys
+import importlib
+
+# from HydPy
+from hydpy.cythons import autogen
+
+autogenpath: str = autogen.__path__[0]
+modulenames = sorted(
+    str(fn.split(".")[0])
+    for fn in os.listdir(autogenpath)
+    if (fn.split(".")[-1] in ("pyd", "so") and not fn.startswith("c_"))
+)
+
+for modulename in modulenames:
+    if not modulename.startswith("callback_"):
+        module = importlib.import_module(f"hydpy.cythons.autogen.{modulename}")
+        sys.modules[f"hydpy.cythons.{modulename}"] = module
+        locals()[modulename] = module

hydpy/cythons/annutils.pxd

@@ -0,0 +1,33 @@
+"""This module defines the Cython declarations related to module |anntools|."""
+
+cimport numpy
+
+
+cdef class ANN:
+
+    # required for usage as an "algorithm" by interputils:
+
+    cdef public int nmb_inputs
+    cdef public int nmb_outputs
+    cdef public double[:] inputs
+    cdef public double[:] outputs
+    cdef public double[:] output_derivatives
+
+    cpdef inline void calculate_values(self) noexcept nogil
+    cpdef inline void calculate_derivatives(self, int idx_input) noexcept nogil
+
+    # algorithm-specific requirements:
+
+    cdef public int nmb_layers
+    cdef public int[:] nmb_neurons
+    cdef public double[:, :] weights_input
+    cdef public double[:, :] weights_output
+    cdef public double[:, :, :] weights_hidden
+    cdef public double[:, :] intercepts_hidden
+    cdef public double[:] intercepts_output
+    cdef public int[:, :] activation
+    cdef public double[:, :] neurons
+    cdef public double[:, :] neuron_derivatives
+
+    cdef inline void apply_activationfunction(self, int idx_layer, int idx_neuron, double input_) noexcept nogil
+    cdef inline double apply_derivativefunction(self, int idx_layer, int idx_neuron, double inner) noexcept nogil

hydpy/cythons/annutils.pyi

@@ -0,0 +1,25 @@
+# pylint: disable=missing-docstring
+
+from hydpy.core.typingtools import *
+
+class ANN:
+    # required for usage as an "algorithm" by interputils:
+    nmb_inputs: int
+    nmb_outputs: int
+    inputs: VectorFloat
+    outputs: VectorFloat
+    output_derivatives: VectorFloat
+    def calculate_values(self) -> None: ...
+    def calculate_derivatives(  # pylint: disable=unused-argument
+        self, idx: int, /
+    ) -> None: ...
+    # algorithm-specific requirements:
+    nmb_layers: int
+    nmb_neurons: VectorInt
+    weights_input: MatrixFloat
+    weights_output: MatrixFloat
+    weights_hidden: TensorFloat
+    intercepts_hidden: MatrixFloat
+    intercepts_output: VectorFloat
+    activation: MatrixInt
+    neurons: MatrixFloat

hydpy/cythons/annutils.pyx

@@ -0,0 +1,120 @@
+"""This Cython module implements the performance-critical methods of the
+Python module |anntools|.
+"""
+
+# import...
+from hydpy.cythons.autogen cimport smoothutils
+# ...cimport
+cimport cython
+from libc.math cimport NAN as nan
+
+
+@cython.final
+cdef class ANN:
+
+    cdef inline void apply_activationfunction(self, int idx_layer, int idx_neuron, double input_) noexcept nogil:
+        if self.activation[idx_layer, idx_neuron] == 1:
+            self.neurons[idx_layer, idx_neuron] = \
+                smoothutils.smooth_logistic1(self.neurons[idx_layer, idx_neuron], 1.0)
+        elif self.activation[idx_layer, idx_neuron] == 2:
+            self.neurons[idx_layer, idx_neuron] = \
+                input_ * smoothutils.smooth_logistic1(self.neurons[idx_layer, idx_neuron], 1.0)
+
+    cdef inline double apply_derivativefunction(self, int idx_layer, int idx_neuron, double inner) noexcept nogil:
+        if self.activation[idx_layer, idx_neuron] in (1, 2):
+            return smoothutils.smooth_logistic1_derivative2(inner, 1.0)
+        return 1.0
+
+    cpdef inline void calculate_values(self) noexcept nogil:
+        cdef int idx_input, idx_neuron1, idx_neuron2, idx_output, idx_layer
+        cdef double input_
+
+        for idx_neuron1 in range(self.nmb_neurons[0]):
+            self.neurons[0, idx_neuron1] = \
+                self.intercepts_hidden[0, idx_neuron1]
+            for idx_input in range(self.nmb_inputs):
+                self.neurons[0, idx_neuron1] += (
+                    self.weights_input[idx_input, idx_neuron1] *
+                    self.inputs[idx_input])
+            if idx_neuron1 < self.nmb_inputs:
+                input_ = self.inputs[idx_neuron1]
+            else:
+                input_ = nan
+            self.apply_activationfunction(0, idx_neuron1, input_)
+
+        for idx_layer in range(1, self.nmb_layers):
+            for idx_neuron1 in range(self.nmb_neurons[idx_layer]):
+                self.neurons[idx_layer, idx_neuron1] = \
+                    self.intercepts_hidden[idx_layer, idx_neuron1]
+                for idx_neuron2 in range(self.nmb_neurons[idx_layer-1]):
+                    self.neurons[idx_layer, idx_neuron1] += (
+                        self.weights_hidden[idx_layer-1, idx_neuron2, idx_neuron1] *
+                        self.neurons[idx_layer-1, idx_neuron2]
+                    )
+                if idx_neuron1 < self.nmb_neurons[idx_layer-1]:
+                    input_ = self.neurons[idx_layer-1, idx_neuron1]
+                else:
+                    input_ = nan
+                self.apply_activationfunction(idx_layer, idx_neuron1, input_)
+
+        for idx_output in range(self.nmb_outputs):
+            self.outputs[idx_output] = self.intercepts_output[idx_output]
+            for idx_neuron2 in range(self.nmb_neurons[self.nmb_layers-1]):
+                self.outputs[idx_output] += (
+                    self.weights_output[idx_neuron2, idx_output] *
+                    self.neurons[self.nmb_layers-1, idx_neuron2]
+                )
+
+
+    cpdef inline void calculate_derivatives(self, int idx_input) noexcept nogil:
+        cdef int idx_neuron1, idx_neuron2, idx_input_, idx_output, idx_layer
+        cdef double weight, input_
+        cdef double der1   # outer derivative
+        cdef double der2   # inner derivative
+        for idx_neuron1 in range(self.nmb_neurons[0]):
+            input_ = self.intercepts_hidden[0, idx_neuron1]
+            for idx_input_ in range(self.nmb_inputs):
+                input_ += (self.weights_input[idx_input_, idx_neuron1] *
+                         self.inputs[idx_input_])
+            der1 = self.apply_derivativefunction(0, idx_neuron1, input_)
+            der2 = self.weights_input[idx_input, idx_neuron1]
+            self.neuron_derivatives[0, idx_neuron1] = der1 * der2
+            if self.activation[0, idx_neuron1] == 2:
+                if idx_neuron1 < self.nmb_inputs:
+                    input_ = self.inputs[idx_neuron1]
+                else:
+                    input_ = nan
+                self.neuron_derivatives[0, idx_neuron1] *= input_
+                if idx_neuron1 == idx_input:
+                    self.neuron_derivatives[0, idx_neuron1] += \
+                        self.neurons[0, idx_neuron1] / input_
+        for idx_layer in range(1, self.nmb_layers):
+            for idx_neuron1 in range(self.nmb_neurons[idx_layer]):
+                input_ = self.intercepts_hidden[idx_layer, idx_neuron1]
+                der2 = 0.0
+                for idx_neuron2 in range(self.nmb_neurons[idx_layer-1]):
+                    weight = self.weights_hidden[
+                        idx_layer-1, idx_neuron2, idx_neuron1]
+                    input_ += weight * self.neurons[idx_layer-1, idx_neuron2]
+                    der2 += weight * self.neuron_derivatives[
+                        idx_layer-1, idx_neuron2]
+                der1 = self.apply_derivativefunction(idx_layer, idx_neuron1, input_)
+                self.neuron_derivatives[idx_layer, idx_neuron1] = der1 * der2
+                if self.activation[idx_layer, idx_neuron1] == 2:
+                    if idx_neuron1 < self.nmb_neurons[idx_layer-1]:
+                        input_ = self.neurons[idx_layer-1, idx_neuron1]
+                    else:
+                        input_ = nan
+                    self.neuron_derivatives[idx_layer, idx_neuron1] *= input_
+                    self.neuron_derivatives[idx_layer, idx_neuron1] += (
+                        self.neurons[idx_layer, idx_neuron1] / input_ *
+                        self.neuron_derivatives[idx_layer-1, idx_neuron1]
+                    )
+        for idx_output in range(self.nmb_outputs):
+            der1 = 1.0
+            der2 = 0.0
+            for idx_neuron2 in range(self.nmb_neurons[self.nmb_layers-1]):
+                der2 += (
+                    self.weights_output[idx_neuron2, idx_output] *
+                    self.neuron_derivatives[self.nmb_layers-1, idx_neuron2])
+            self.output_derivatives[idx_output] = der1 * der2

hydpy/cythons/autogen/annutils.pxd

@@ -0,0 +1,42 @@
+# !python
+# distutils: define_macros=NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION
+# cython: language_level=3
+# cython: cpow=True
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: initializedcheck=False
+# cython: cdivision=True
+
+"""This module defines the Cython declarations related to module |anntools|."""
+
+cimport numpy
+
+
+cdef class ANN:
+
+    # required for usage as an "algorithm" by interputils:
+
+    cdef public numpy.int64_t nmb_inputs
+    cdef public numpy.int64_t nmb_outputs
+    cdef public double[:] inputs
+    cdef public double[:] outputs
+    cdef public double[:] output_derivatives
+
+    cpdef inline void calculate_values(self) noexcept nogil
+    cpdef inline void calculate_derivatives(self, numpy.int64_t idx_input) noexcept nogil
+
+    # algorithm-specific requirements:
+
+    cdef public numpy.int64_t nmb_layers
+    cdef public numpy.int64_t[:] nmb_neurons
+    cdef public double[:, :] weights_input
+    cdef public double[:, :] weights_output
+    cdef public double[:, :, :] weights_hidden
+    cdef public double[:, :] intercepts_hidden
+    cdef public double[:] intercepts_output
+    cdef public numpy.int64_t[:, :] activation
+    cdef public double[:, :] neurons
+    cdef public double[:, :] neuron_derivatives
+
+    cdef inline void apply_activationfunction(self, numpy.int64_t idx_layer, numpy.int64_t idx_neuron, double input_) noexcept nogil
+    cdef inline double apply_derivativefunction(self, numpy.int64_t idx_layer, numpy.int64_t idx_neuron, double inner) noexcept nogil

hydpy/cythons/autogen/annutils.pyx

@@ -0,0 +1,129 @@
+# !python
+# distutils: define_macros=NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION
+# cython: language_level=3
+# cython: cpow=True
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: initializedcheck=False
+# cython: cdivision=True
+
+"""This Cython module implements the performance-critical methods of the
+Python module |anntools|.
+"""
+
+# import...
+from hydpy.cythons.autogen cimport smoothutils
+# ...cimport
+cimport cython
+from libc.math cimport NAN as nan
+
+
+@cython.final
+cdef class ANN:
+
+    cdef inline void apply_activationfunction(self, numpy.int64_t idx_layer, numpy.int64_t idx_neuron, double input_) noexcept nogil:
+        if self.activation[idx_layer, idx_neuron] == 1:
+            self.neurons[idx_layer, idx_neuron] = \
+                smoothutils.smooth_logistic1(self.neurons[idx_layer, idx_neuron], 1.0)
+        elif self.activation[idx_layer, idx_neuron] == 2:
+            self.neurons[idx_layer, idx_neuron] = \
+                input_ * smoothutils.smooth_logistic1(self.neurons[idx_layer, idx_neuron], 1.0)
+
+    cdef inline double apply_derivativefunction(self, numpy.int64_t idx_layer, numpy.int64_t idx_neuron, double inner) noexcept nogil:
+        if self.activation[idx_layer, idx_neuron] in (1, 2):
+            return smoothutils.smooth_logistic1_derivative2(inner, 1.0)
+        return 1.0
+
+    cpdef inline void calculate_values(self) noexcept nogil:
+        cdef numpy.int64_t idx_input, idx_neuron1, idx_neuron2, idx_output, idx_layer
+        cdef double input_
+
+        for idx_neuron1 in range(self.nmb_neurons[0]):
+            self.neurons[0, idx_neuron1] = \
+                self.intercepts_hidden[0, idx_neuron1]
+            for idx_input in range(self.nmb_inputs):
+                self.neurons[0, idx_neuron1] += (
+                    self.weights_input[idx_input, idx_neuron1] *
+                    self.inputs[idx_input])
+            if idx_neuron1 < self.nmb_inputs:
+                input_ = self.inputs[idx_neuron1]
+            else:
+                input_ = nan
+            self.apply_activationfunction(0, idx_neuron1, input_)
+
+        for idx_layer in range(1, self.nmb_layers):
+            for idx_neuron1 in range(self.nmb_neurons[idx_layer]):
+                self.neurons[idx_layer, idx_neuron1] = \
+                    self.intercepts_hidden[idx_layer, idx_neuron1]
+                for idx_neuron2 in range(self.nmb_neurons[idx_layer-1]):
+                    self.neurons[idx_layer, idx_neuron1] += (
+                        self.weights_hidden[idx_layer-1, idx_neuron2, idx_neuron1] *
+                        self.neurons[idx_layer-1, idx_neuron2]
+                    )
+                if idx_neuron1 < self.nmb_neurons[idx_layer-1]:
+                    input_ = self.neurons[idx_layer-1, idx_neuron1]
+                else:
+                    input_ = nan
+                self.apply_activationfunction(idx_layer, idx_neuron1, input_)
+
+        for idx_output in range(self.nmb_outputs):
+            self.outputs[idx_output] = self.intercepts_output[idx_output]
+            for idx_neuron2 in range(self.nmb_neurons[self.nmb_layers-1]):
+                self.outputs[idx_output] += (
+                    self.weights_output[idx_neuron2, idx_output] *
+                    self.neurons[self.nmb_layers-1, idx_neuron2]
+                )
+
+
+    cpdef inline void calculate_derivatives(self, numpy.int64_t idx_input) noexcept nogil:
+        cdef numpy.int64_t idx_neuron1, idx_neuron2, idx_input_, idx_output, idx_layer
+        cdef double weight, input_
+        cdef double der1   # outer derivative
+        cdef double der2   # inner derivative
+        for idx_neuron1 in range(self.nmb_neurons[0]):
+            input_ = self.intercepts_hidden[0, idx_neuron1]
+            for idx_input_ in range(self.nmb_inputs):
+                input_ += (self.weights_input[idx_input_, idx_neuron1] *
+                         self.inputs[idx_input_])
+            der1 = self.apply_derivativefunction(0, idx_neuron1, input_)
+            der2 = self.weights_input[idx_input, idx_neuron1]
+            self.neuron_derivatives[0, idx_neuron1] = der1 * der2
+            if self.activation[0, idx_neuron1] == 2:
+                if idx_neuron1 < self.nmb_inputs:
+                    input_ = self.inputs[idx_neuron1]
+                else:
+                    input_ = nan
+                self.neuron_derivatives[0, idx_neuron1] *= input_
+                if idx_neuron1 == idx_input:
+                    self.neuron_derivatives[0, idx_neuron1] += \
+                        self.neurons[0, idx_neuron1] / input_
+        for idx_layer in range(1, self.nmb_layers):
+            for idx_neuron1 in range(self.nmb_neurons[idx_layer]):
+                input_ = self.intercepts_hidden[idx_layer, idx_neuron1]
+                der2 = 0.0
+                for idx_neuron2 in range(self.nmb_neurons[idx_layer-1]):
+                    weight = self.weights_hidden[
+                        idx_layer-1, idx_neuron2, idx_neuron1]
+                    input_ += weight * self.neurons[idx_layer-1, idx_neuron2]
+                    der2 += weight * self.neuron_derivatives[
+                        idx_layer-1, idx_neuron2]
+                der1 = self.apply_derivativefunction(idx_layer, idx_neuron1, input_)
+                self.neuron_derivatives[idx_layer, idx_neuron1] = der1 * der2
+                if self.activation[idx_layer, idx_neuron1] == 2:
+                    if idx_neuron1 < self.nmb_neurons[idx_layer-1]:
+                        input_ = self.neurons[idx_layer-1, idx_neuron1]
+                    else:
+                        input_ = nan
+                    self.neuron_derivatives[idx_layer, idx_neuron1] *= input_
+                    self.neuron_derivatives[idx_layer, idx_neuron1] += (
+                        self.neurons[idx_layer, idx_neuron1] / input_ *
+                        self.neuron_derivatives[idx_layer-1, idx_neuron1]
+                    )
+        for idx_output in range(self.nmb_outputs):
+            der1 = 1.0
+            der2 = 0.0
+            for idx_neuron2 in range(self.nmb_neurons[self.nmb_layers-1]):
+                der2 += (
+                    self.weights_output[idx_neuron2, idx_output] *
+                    self.neuron_derivatives[self.nmb_layers-1, idx_neuron2])
+            self.output_derivatives[idx_output] = der1 * der2

hydpy/cythons/autogen/c_arma.pxd

@@ -0,0 +1,179 @@
+#!python
+# distutils: define_macros=NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION
+# cython: language_level=3
+# cython: cpow=True
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: initializedcheck=False
+# cython: cdivision=True
+from typing import Optional
+import numpy
+cimport numpy
+from libc.math cimport exp, fabs, log, sin, cos, tan, tanh, asin, acos, atan, isnan, isinf
+from libc.math cimport NAN as nan
+from libc.math cimport INFINITY as inf
+import cython
+from cpython.mem cimport PyMem_Malloc
+from cpython.mem cimport PyMem_Realloc
+from cpython.mem cimport PyMem_Free
+from hydpy.cythons.autogen cimport configutils
+from hydpy.cythons.autogen cimport interfaceutils
+from hydpy.cythons.autogen cimport interputils
+from hydpy.cythons.autogen import pointerutils
+from hydpy.cythons.autogen cimport pointerutils
+from hydpy.cythons.autogen cimport quadutils
+from hydpy.cythons.autogen cimport rootutils
+from hydpy.cythons.autogen cimport smoothutils
+from hydpy.cythons.autogen cimport masterinterface
+ctypedef void (*CallbackType) (Model)  noexcept nogil
+cdef class CallbackWrapper:
+    cdef CallbackType callback
+@cython.final
+cdef class Parameters:
+    cdef public ControlParameters control
+    cdef public DerivedParameters derived
+@cython.final
+cdef class ControlParameters:
+    cdef public double responses
+@cython.final
+cdef class DerivedParameters:
+    cdef public numpy.int64_t nmb
+    cdef public double[:] maxq
+    cdef public double[:] diffq
+    cdef public numpy.int64_t[:] ar_order
+    cdef public numpy.int64_t[:] ma_order
+    cdef public double[:,:] ar_coefs
+    cdef public double[:,:] ma_coefs
+@cython.final
+cdef class Sequences:
+    cdef public InletSequences inlets
+    cdef public FluxSequences fluxes
+    cdef public LogSequences logs
+    cdef public OutletSequences outlets
+@cython.final
+cdef class InletSequences:
+    cdef double **q
+    cdef public numpy.int64_t len_q
+    cdef public numpy.int64_t[:] _q_ready
+    cdef public numpy.int64_t _q_ndim
+    cdef public numpy.int64_t _q_length
+    cdef public numpy.int64_t _q_length_0
+    cpdef inline alloc(self, name, numpy.int64_t length)
+    cpdef inline dealloc(self, name)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx)
+    cpdef get_value(self, str name)
+    cpdef set_value(self, str name, value)
+@cython.final
+cdef class FluxSequences:
+    cdef public double qin
+    cdef public numpy.int64_t _qin_ndim
+    cdef public numpy.int64_t _qin_length
+    cdef public bint _qin_ramflag
+    cdef public double[:] _qin_array
+    cdef public bint _qin_diskflag_reading
+    cdef public bint _qin_diskflag_writing
+    cdef public double[:] _qin_ncarray
+    cdef public bint _qin_outputflag
+    cdef double *_qin_outputpointer
+    cdef public double[:] qpin
+    cdef public numpy.int64_t _qpin_ndim
+    cdef public numpy.int64_t _qpin_length
+    cdef public numpy.int64_t _qpin_length_0
+    cdef public bint _qpin_ramflag
+    cdef public double[:,:] _qpin_array
+    cdef public bint _qpin_diskflag_reading
+    cdef public bint _qpin_diskflag_writing
+    cdef public double[:] _qpin_ncarray
+    cdef public double[:] qma
+    cdef public numpy.int64_t _qma_ndim
+    cdef public numpy.int64_t _qma_length
+    cdef public numpy.int64_t _qma_length_0
+    cdef public bint _qma_ramflag
+    cdef public double[:,:] _qma_array
+    cdef public bint _qma_diskflag_reading
+    cdef public bint _qma_diskflag_writing
+    cdef public double[:] _qma_ncarray
+    cdef public double[:] qar
+    cdef public numpy.int64_t _qar_ndim
+    cdef public numpy.int64_t _qar_length
+    cdef public numpy.int64_t _qar_length_0
+    cdef public bint _qar_ramflag
+    cdef public double[:,:] _qar_array
+    cdef public bint _qar_diskflag_reading
+    cdef public bint _qar_diskflag_writing
+    cdef public double[:] _qar_ncarray
+    cdef public double[:] qpout
+    cdef public numpy.int64_t _qpout_ndim
+    cdef public numpy.int64_t _qpout_length
+    cdef public numpy.int64_t _qpout_length_0
+    cdef public bint _qpout_ramflag
+    cdef public double[:,:] _qpout_array
+    cdef public bint _qpout_diskflag_reading
+    cdef public bint _qpout_diskflag_writing
+    cdef public double[:] _qpout_ncarray
+    cdef public double qout
+    cdef public numpy.int64_t _qout_ndim
+    cdef public numpy.int64_t _qout_length
+    cdef public bint _qout_ramflag
+    cdef public double[:] _qout_array
+    cdef public bint _qout_diskflag_reading
+    cdef public bint _qout_diskflag_writing
+    cdef public double[:] _qout_ncarray
+    cdef public bint _qout_outputflag
+    cdef double *_qout_outputpointer
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value)
+    cpdef inline void update_outputs(self) noexcept nogil
+@cython.final
+cdef class LogSequences:
+    cdef public double[:,:] login
+    cdef public numpy.int64_t _login_ndim
+    cdef public numpy.int64_t _login_length
+    cdef public numpy.int64_t _login_length_0
+    cdef public numpy.int64_t _login_length_1
+    cdef public double[:,:] logout
+    cdef public numpy.int64_t _logout_ndim
+    cdef public numpy.int64_t _logout_length
+    cdef public numpy.int64_t _logout_length_0
+    cdef public numpy.int64_t _logout_length_1
+@cython.final
+cdef class OutletSequences:
+    cdef double *q
+    cdef public numpy.int64_t _q_ndim
+    cdef public numpy.int64_t _q_length
+    cpdef inline set_pointer0d(self, str name, pointerutils.Double value)
+    cpdef get_value(self, str name)
+    cpdef set_value(self, str name, value)
+@cython.final
+cdef class Model:
+    cdef public numpy.int64_t idx_sim
+    cdef public Parameters parameters
+    cdef public Sequences sequences
+    cpdef inline void simulate(self, numpy.int64_t idx)  noexcept nogil
+    cpdef void reset_reuseflags(self) noexcept nogil
+    cpdef void save_data(self, numpy.int64_t idx) noexcept nogil
+    cpdef inline void run(self) noexcept nogil
+    cpdef inline void update_inlets(self) noexcept nogil
+    cpdef inline void update_outlets(self) noexcept nogil
+    cpdef inline void update_receivers(self, numpy.int64_t idx) noexcept nogil
+    cpdef inline void update_senders(self, numpy.int64_t idx) noexcept nogil
+    cpdef inline void update_outputs(self) noexcept nogil
+    cpdef inline void pick_q_v1(self) noexcept nogil
+    cpdef inline void calc_qpin_v1(self) noexcept nogil
+    cpdef inline void update_login_v1(self) noexcept nogil
+    cpdef inline void calc_qma_v1(self) noexcept nogil
+    cpdef inline void calc_qar_v1(self) noexcept nogil
+    cpdef inline void calc_qpout_v1(self) noexcept nogil
+    cpdef inline void update_logout_v1(self) noexcept nogil
+    cpdef inline void calc_qout_v1(self) noexcept nogil
+    cpdef inline void pass_q_v1(self) noexcept nogil
+    cpdef inline void pick_q(self) noexcept nogil
+    cpdef inline void calc_qpin(self) noexcept nogil
+    cpdef inline void update_login(self) noexcept nogil
+    cpdef inline void calc_qma(self) noexcept nogil
+    cpdef inline void calc_qar(self) noexcept nogil
+    cpdef inline void calc_qpout(self) noexcept nogil
+    cpdef inline void update_logout(self) noexcept nogil
+    cpdef inline void calc_qout(self) noexcept nogil
+    cpdef inline void pass_q(self) noexcept nogil