HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy/cythons/autogen/c_arma_rimorido.pyx

@@ -0,0 +1,356 @@
+#!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
+
+
+cdef void do_nothing(Model model)  noexcept nogil:
+    pass
+
+cpdef get_wrapper():
+    cdef CallbackWrapper wrapper = CallbackWrapper()
+    wrapper.callback = do_nothing
+    return wrapper
+
+@cython.final
+cdef class Parameters:
+    pass
+@cython.final
+cdef class ControlParameters:
+    pass
+@cython.final
+cdef class DerivedParameters:
+    pass
+@cython.final
+cdef class Sequences:
+    pass
+@cython.final
+cdef class InletSequences:
+    cpdef inline alloc(self, name, numpy.int64_t length):
+        if name == "q":
+            self._q_length_0 = length
+            self._q_ready = numpy.full(length, 0, dtype=numpy.int64)
+            self.q = <double**> PyMem_Malloc(length * sizeof(double*))
+    cpdef inline dealloc(self, name):
+        if name == "q":
+            PyMem_Free(self.q)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "q":
+            self.q[idx] = pointer.p_value
+            self._q_ready[idx] = 1
+    cpdef get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "q":
+            values = numpy.empty(self.len_q)
+            for idx in range(self.len_q):
+                pointerutils.check0(self._q_length_0)
+                if self._q_ready[idx] == 0:
+                    pointerutils.check1(self._q_length_0, idx)
+                    pointerutils.check2(self._q_ready, idx)
+                values[idx] = self.q[idx][0]
+            return values
+    cpdef set_value(self, str name, value):
+        if name == "q":
+            for idx in range(self.len_q):
+                pointerutils.check0(self._q_length_0)
+                if self._q_ready[idx] == 0:
+                    pointerutils.check1(self._q_length_0, idx)
+                    pointerutils.check2(self._q_ready, idx)
+                self.q[idx][0] = value[idx]
+@cython.final
+cdef class FluxSequences:
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t jdx0
+        cdef numpy.int64_t k
+        if self._qin_diskflag_reading:
+            self.qin = self._qin_ncarray[0]
+        elif self._qin_ramflag:
+            self.qin = self._qin_array[idx]
+        if self._qpin_diskflag_reading:
+            k = 0
+            for jdx0 in range(self._qpin_length_0):
+                self.qpin[jdx0] = self._qpin_ncarray[k]
+                k += 1
+        elif self._qpin_ramflag:
+            for jdx0 in range(self._qpin_length_0):
+                self.qpin[jdx0] = self._qpin_array[idx, jdx0]
+        if self._qma_diskflag_reading:
+            k = 0
+            for jdx0 in range(self._qma_length_0):
+                self.qma[jdx0] = self._qma_ncarray[k]
+                k += 1
+        elif self._qma_ramflag:
+            for jdx0 in range(self._qma_length_0):
+                self.qma[jdx0] = self._qma_array[idx, jdx0]
+        if self._qar_diskflag_reading:
+            k = 0
+            for jdx0 in range(self._qar_length_0):
+                self.qar[jdx0] = self._qar_ncarray[k]
+                k += 1
+        elif self._qar_ramflag:
+            for jdx0 in range(self._qar_length_0):
+                self.qar[jdx0] = self._qar_array[idx, jdx0]
+        if self._qpout_diskflag_reading:
+            k = 0
+            for jdx0 in range(self._qpout_length_0):
+                self.qpout[jdx0] = self._qpout_ncarray[k]
+                k += 1
+        elif self._qpout_ramflag:
+            for jdx0 in range(self._qpout_length_0):
+                self.qpout[jdx0] = self._qpout_array[idx, jdx0]
+        if self._qout_diskflag_reading:
+            self.qout = self._qout_ncarray[0]
+        elif self._qout_ramflag:
+            self.qout = self._qout_array[idx]
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t jdx0
+        cdef numpy.int64_t k
+        if self._qin_diskflag_writing:
+            self._qin_ncarray[0] = self.qin
+        if self._qin_ramflag:
+            self._qin_array[idx] = self.qin
+        if self._qpin_diskflag_writing:
+            k = 0
+            for jdx0 in range(self._qpin_length_0):
+                self._qpin_ncarray[k] = self.qpin[jdx0]
+                k += 1
+        if self._qpin_ramflag:
+            for jdx0 in range(self._qpin_length_0):
+                self._qpin_array[idx, jdx0] = self.qpin[jdx0]
+        if self._qma_diskflag_writing:
+            k = 0
+            for jdx0 in range(self._qma_length_0):
+                self._qma_ncarray[k] = self.qma[jdx0]
+                k += 1
+        if self._qma_ramflag:
+            for jdx0 in range(self._qma_length_0):
+                self._qma_array[idx, jdx0] = self.qma[jdx0]
+        if self._qar_diskflag_writing:
+            k = 0
+            for jdx0 in range(self._qar_length_0):
+                self._qar_ncarray[k] = self.qar[jdx0]
+                k += 1
+        if self._qar_ramflag:
+            for jdx0 in range(self._qar_length_0):
+                self._qar_array[idx, jdx0] = self.qar[jdx0]
+        if self._qpout_diskflag_writing:
+            k = 0
+            for jdx0 in range(self._qpout_length_0):
+                self._qpout_ncarray[k] = self.qpout[jdx0]
+                k += 1
+        if self._qpout_ramflag:
+            for jdx0 in range(self._qpout_length_0):
+                self._qpout_array[idx, jdx0] = self.qpout[jdx0]
+        if self._qout_diskflag_writing:
+            self._qout_ncarray[0] = self.qout
+        if self._qout_ramflag:
+            self._qout_array[idx] = self.qout
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value):
+        if name == "qin":
+            self._qin_outputpointer = value.p_value
+        if name == "qout":
+            self._qout_outputpointer = value.p_value
+    cpdef inline void update_outputs(self) noexcept nogil:
+        if self._qin_outputflag:
+            self._qin_outputpointer[0] = self.qin
+        if self._qout_outputflag:
+            self._qout_outputpointer[0] = self.qout
+@cython.final
+cdef class LogSequences:
+    pass
+@cython.final
+cdef class OutletSequences:
+    cpdef inline set_pointer0d(self, str name, pointerutils.Double value):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "q":
+            self.q = pointer.p_value
+    cpdef get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "q":
+            return self.q[0]
+    cpdef set_value(self, str name, value):
+        if name == "q":
+            self.q[0] = value
+@cython.final
+cdef class Model:
+    cpdef inline void simulate(self, numpy.int64_t idx)  noexcept nogil:
+        self.idx_sim = idx
+        self.update_inlets()
+        self.run()
+        self.update_outlets()
+        self.update_outputs()
+    cpdef void reset_reuseflags(self) noexcept nogil:
+        pass
+    cpdef void save_data(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        self.sequences.fluxes.save_data(idx)
+    cpdef inline void run(self) noexcept nogil:
+        self.calc_qpin_v1()
+        self.update_login_v1()
+        self.calc_qma_v1()
+        self.calc_qar_v1()
+        self.calc_qpout_v1()
+        self.update_logout_v1()
+        self.calc_qout_v1()
+    cpdef inline void update_inlets(self) noexcept nogil:
+        self.pick_q_v1()
+    cpdef inline void update_outlets(self) noexcept nogil:
+        self.pass_q_v1()
+    cpdef inline void update_receivers(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        pass
+    cpdef inline void update_senders(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        pass
+    cpdef inline void update_outputs(self) noexcept nogil:
+        self.sequences.fluxes.update_outputs()
+    cpdef inline void pick_q_v1(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.qin = 0.0
+        for idx in range(self.sequences.inlets.len_q):
+            self.sequences.fluxes.qin = self.sequences.fluxes.qin + (self.sequences.inlets.q[idx][0])
+    cpdef inline void calc_qpin_v1(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb - 1):
+            if self.sequences.fluxes.qin < self.parameters.derived.maxq[idx]:
+                if idx == 0:
+                    self.sequences.fluxes.qpin[idx] = self.sequences.fluxes.qin
+                else:
+                    self.sequences.fluxes.qpin[idx] = 0.0
+            elif self.sequences.fluxes.qin < self.parameters.derived.maxq[idx + 1]:
+                self.sequences.fluxes.qpin[idx] = self.sequences.fluxes.qin - self.parameters.derived.maxq[idx]
+            else:
+                self.sequences.fluxes.qpin[idx] = self.parameters.derived.diffq[idx]
+        if self.parameters.derived.nmb == 1:
+            self.sequences.fluxes.qpin[0] = self.sequences.fluxes.qin
+        else:
+            self.sequences.fluxes.qpin[self.parameters.derived.nmb - 1] = max(self.sequences.fluxes.qin - self.parameters.derived.maxq[self.parameters.derived.nmb - 1], 0.0)
+    cpdef inline void update_login_v1(self) noexcept nogil:
+        cdef numpy.int64_t jdx
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb):
+            for jdx in range(self.parameters.derived.ma_order[idx] - 2, -1, -1):
+                self.sequences.logs.login[idx, jdx + 1] = self.sequences.logs.login[idx, jdx]
+        for idx in range(self.parameters.derived.nmb):
+            self.sequences.logs.login[idx, 0] = self.sequences.fluxes.qpin[idx]
+    cpdef inline void calc_qma_v1(self) noexcept nogil:
+        cdef numpy.int64_t jdx
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb):
+            self.sequences.fluxes.qma[idx] = 0.0
+            for jdx in range(self.parameters.derived.ma_order[idx]):
+                self.sequences.fluxes.qma[idx] = self.sequences.fluxes.qma[idx] + (self.parameters.derived.ma_coefs[idx, jdx] * self.sequences.logs.login[idx, jdx])
+    cpdef inline void calc_qar_v1(self) noexcept nogil:
+        cdef numpy.int64_t jdx
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb):
+            self.sequences.fluxes.qar[idx] = 0.0
+            for jdx in range(self.parameters.derived.ar_order[idx]):
+                self.sequences.fluxes.qar[idx] = self.sequences.fluxes.qar[idx] + (self.parameters.derived.ar_coefs[idx, jdx] * self.sequences.logs.logout[idx, jdx])
+    cpdef inline void calc_qpout_v1(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb):
+            self.sequences.fluxes.qpout[idx] = self.sequences.fluxes.qma[idx] + self.sequences.fluxes.qar[idx]
+    cpdef inline void update_logout_v1(self) noexcept nogil:
+        cdef numpy.int64_t jdx
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb):
+            for jdx in range(self.parameters.derived.ar_order[idx] - 2, -1, -1):
+                self.sequences.logs.logout[idx, jdx + 1] = self.sequences.logs.logout[idx, jdx]
+        for idx in range(self.parameters.derived.nmb):
+            if self.parameters.derived.ar_order[idx] > 0:
+                self.sequences.logs.logout[idx, 0] = self.sequences.fluxes.qpout[idx]
+    cpdef inline void calc_qout_v1(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.qout = 0.0
+        for idx in range(self.parameters.derived.nmb):
+            self.sequences.fluxes.qout = self.sequences.fluxes.qout + (self.sequences.fluxes.qpout[idx])
+    cpdef inline void pass_q_v1(self) noexcept nogil:
+        self.sequences.outlets.q[0] = self.sequences.outlets.q[0] + (self.sequences.fluxes.qout)
+    cpdef inline void pick_q(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.qin = 0.0
+        for idx in range(self.sequences.inlets.len_q):
+            self.sequences.fluxes.qin = self.sequences.fluxes.qin + (self.sequences.inlets.q[idx][0])
+    cpdef inline void calc_qpin(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb - 1):
+            if self.sequences.fluxes.qin < self.parameters.derived.maxq[idx]:
+                if idx == 0:
+                    self.sequences.fluxes.qpin[idx] = self.sequences.fluxes.qin
+                else:
+                    self.sequences.fluxes.qpin[idx] = 0.0
+            elif self.sequences.fluxes.qin < self.parameters.derived.maxq[idx + 1]:
+                self.sequences.fluxes.qpin[idx] = self.sequences.fluxes.qin - self.parameters.derived.maxq[idx]
+            else:
+                self.sequences.fluxes.qpin[idx] = self.parameters.derived.diffq[idx]
+        if self.parameters.derived.nmb == 1:
+            self.sequences.fluxes.qpin[0] = self.sequences.fluxes.qin
+        else:
+            self.sequences.fluxes.qpin[self.parameters.derived.nmb - 1] = max(self.sequences.fluxes.qin - self.parameters.derived.maxq[self.parameters.derived.nmb - 1], 0.0)
+    cpdef inline void update_login(self) noexcept nogil:
+        cdef numpy.int64_t jdx
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb):
+            for jdx in range(self.parameters.derived.ma_order[idx] - 2, -1, -1):
+                self.sequences.logs.login[idx, jdx + 1] = self.sequences.logs.login[idx, jdx]
+        for idx in range(self.parameters.derived.nmb):
+            self.sequences.logs.login[idx, 0] = self.sequences.fluxes.qpin[idx]
+    cpdef inline void calc_qma(self) noexcept nogil:
+        cdef numpy.int64_t jdx
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb):
+            self.sequences.fluxes.qma[idx] = 0.0
+            for jdx in range(self.parameters.derived.ma_order[idx]):
+                self.sequences.fluxes.qma[idx] = self.sequences.fluxes.qma[idx] + (self.parameters.derived.ma_coefs[idx, jdx] * self.sequences.logs.login[idx, jdx])
+    cpdef inline void calc_qar(self) noexcept nogil:
+        cdef numpy.int64_t jdx
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb):
+            self.sequences.fluxes.qar[idx] = 0.0
+            for jdx in range(self.parameters.derived.ar_order[idx]):
+                self.sequences.fluxes.qar[idx] = self.sequences.fluxes.qar[idx] + (self.parameters.derived.ar_coefs[idx, jdx] * self.sequences.logs.logout[idx, jdx])
+    cpdef inline void calc_qpout(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb):
+            self.sequences.fluxes.qpout[idx] = self.sequences.fluxes.qma[idx] + self.sequences.fluxes.qar[idx]
+    cpdef inline void update_logout(self) noexcept nogil:
+        cdef numpy.int64_t jdx
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.derived.nmb):
+            for jdx in range(self.parameters.derived.ar_order[idx] - 2, -1, -1):
+                self.sequences.logs.logout[idx, jdx + 1] = self.sequences.logs.logout[idx, jdx]
+        for idx in range(self.parameters.derived.nmb):
+            if self.parameters.derived.ar_order[idx] > 0:
+                self.sequences.logs.logout[idx, 0] = self.sequences.fluxes.qpout[idx]
+    cpdef inline void calc_qout(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.qout = 0.0
+        for idx in range(self.parameters.derived.nmb):
+            self.sequences.fluxes.qout = self.sequences.fluxes.qout + (self.sequences.fluxes.qpout[idx])
+    cpdef inline void pass_q(self) noexcept nogil:
+        self.sequences.outlets.q[0] = self.sequences.outlets.q[0] + (self.sequences.fluxes.qout)

hydpy/cythons/autogen/c_conv.pxd

@@ -0,0 +1,198 @@
+#!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[:,:] inputcoordinates
+    cdef public double[:,:] outputcoordinates
+    cdef public double[:] inputheights
+    cdef public double[:] outputheights
+    cdef public numpy.int64_t maxnmbinputs
+    cdef public numpy.int64_t minnmbinputs
+    cdef public double defaultconstant
+    cdef public double defaultfactor
+    cdef public double power
+@cython.final
+cdef class DerivedParameters:
+    cdef public numpy.int64_t nmbinputs
+    cdef public numpy.int64_t nmboutputs
+    cdef public double[:,:] distances
+    cdef public numpy.int64_t[:,:] proximityorder
+    cdef public double[:,:] weights
+@cython.final
+cdef class Sequences:
+    cdef public InletSequences inlets
+    cdef public FluxSequences fluxes
+    cdef public OutletSequences outlets
+@cython.final
+cdef class InletSequences:
+    cdef double **inputs
+    cdef public numpy.int64_t len_inputs
+    cdef public numpy.int64_t[:] _inputs_ready
+    cdef public numpy.int64_t _inputs_ndim
+    cdef public numpy.int64_t _inputs_length
+    cdef public numpy.int64_t _inputs_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[:] inputs
+    cdef public numpy.int64_t _inputs_ndim
+    cdef public numpy.int64_t _inputs_length
+    cdef public numpy.int64_t _inputs_length_0
+    cdef public bint _inputs_ramflag
+    cdef public double[:,:] _inputs_array
+    cdef public bint _inputs_diskflag_reading
+    cdef public bint _inputs_diskflag_writing
+    cdef public double[:] _inputs_ncarray
+    cdef public double actualconstant
+    cdef public numpy.int64_t _actualconstant_ndim
+    cdef public numpy.int64_t _actualconstant_length
+    cdef public bint _actualconstant_ramflag
+    cdef public double[:] _actualconstant_array
+    cdef public bint _actualconstant_diskflag_reading
+    cdef public bint _actualconstant_diskflag_writing
+    cdef public double[:] _actualconstant_ncarray
+    cdef public bint _actualconstant_outputflag
+    cdef double *_actualconstant_outputpointer
+    cdef public double actualfactor
+    cdef public numpy.int64_t _actualfactor_ndim
+    cdef public numpy.int64_t _actualfactor_length
+    cdef public bint _actualfactor_ramflag
+    cdef public double[:] _actualfactor_array
+    cdef public bint _actualfactor_diskflag_reading
+    cdef public bint _actualfactor_diskflag_writing
+    cdef public double[:] _actualfactor_ncarray
+    cdef public bint _actualfactor_outputflag
+    cdef double *_actualfactor_outputpointer
+    cdef public double[:] inputpredictions
+    cdef public numpy.int64_t _inputpredictions_ndim
+    cdef public numpy.int64_t _inputpredictions_length
+    cdef public numpy.int64_t _inputpredictions_length_0
+    cdef public bint _inputpredictions_ramflag
+    cdef public double[:,:] _inputpredictions_array
+    cdef public bint _inputpredictions_diskflag_reading
+    cdef public bint _inputpredictions_diskflag_writing
+    cdef public double[:] _inputpredictions_ncarray
+    cdef public double[:] outputpredictions
+    cdef public numpy.int64_t _outputpredictions_ndim
+    cdef public numpy.int64_t _outputpredictions_length
+    cdef public numpy.int64_t _outputpredictions_length_0
+    cdef public bint _outputpredictions_ramflag
+    cdef public double[:,:] _outputpredictions_array
+    cdef public bint _outputpredictions_diskflag_reading
+    cdef public bint _outputpredictions_diskflag_writing
+    cdef public double[:] _outputpredictions_ncarray
+    cdef public double[:] inputresiduals
+    cdef public numpy.int64_t _inputresiduals_ndim
+    cdef public numpy.int64_t _inputresiduals_length
+    cdef public numpy.int64_t _inputresiduals_length_0
+    cdef public bint _inputresiduals_ramflag
+    cdef public double[:,:] _inputresiduals_array
+    cdef public bint _inputresiduals_diskflag_reading
+    cdef public bint _inputresiduals_diskflag_writing
+    cdef public double[:] _inputresiduals_ncarray
+    cdef public double[:] outputresiduals
+    cdef public numpy.int64_t _outputresiduals_ndim
+    cdef public numpy.int64_t _outputresiduals_length
+    cdef public numpy.int64_t _outputresiduals_length_0
+    cdef public bint _outputresiduals_ramflag
+    cdef public double[:,:] _outputresiduals_array
+    cdef public bint _outputresiduals_diskflag_reading
+    cdef public bint _outputresiduals_diskflag_writing
+    cdef public double[:] _outputresiduals_ncarray
+    cdef public double[:] outputs
+    cdef public numpy.int64_t _outputs_ndim
+    cdef public numpy.int64_t _outputs_length
+    cdef public numpy.int64_t _outputs_length_0
+    cdef public bint _outputs_ramflag
+    cdef public double[:,:] _outputs_array
+    cdef public bint _outputs_diskflag_reading
+    cdef public bint _outputs_diskflag_writing
+    cdef public double[:] _outputs_ncarray
+    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 OutletSequences:
+    cdef double **outputs
+    cdef public numpy.int64_t len_outputs
+    cdef public numpy.int64_t[:] _outputs_ready
+    cdef public numpy.int64_t _outputs_ndim
+    cdef public numpy.int64_t _outputs_length
+    cdef public numpy.int64_t _outputs_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 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_inputs_v1(self) noexcept nogil
+    cpdef inline void calc_actualconstant_actualfactor_v1(self) noexcept nogil
+    cpdef inline void calc_inputpredictions_v1(self) noexcept nogil
+    cpdef inline void calc_outputpredictions_v1(self) noexcept nogil
+    cpdef inline void calc_inputresiduals_v1(self) noexcept nogil
+    cpdef inline void calc_outputs_v1(self) noexcept nogil
+    cpdef inline void calc_outputs_v2(self) noexcept nogil
+    cpdef inline void calc_outputresiduals_v1(self) noexcept nogil
+    cpdef inline void calc_outputs_v3(self) noexcept nogil
+    cpdef inline double return_mean_v1(self, double[:] values, double[:] mask, numpy.int64_t number) noexcept nogil
+    cpdef inline void interpolate_inversedistance_v1(self, double[:] inputs, double[:] outputs) noexcept nogil
+    cpdef inline void pass_outputs_v1(self) noexcept nogil
+    cpdef inline void pick_inputs(self) noexcept nogil
+    cpdef inline void calc_actualconstant_actualfactor(self) noexcept nogil
+    cpdef inline void calc_inputpredictions(self) noexcept nogil
+    cpdef inline void calc_outputpredictions(self) noexcept nogil
+    cpdef inline void calc_inputresiduals(self) noexcept nogil
+    cpdef inline void calc_outputresiduals(self) noexcept nogil
+    cpdef inline double return_mean(self, double[:] values, double[:] mask, numpy.int64_t number) noexcept nogil
+    cpdef inline void interpolate_inversedistance(self, double[:] inputs, double[:] outputs) noexcept nogil
+    cpdef inline void pass_outputs(self) noexcept nogil