From fd0586072579f04957377285a89490135fe20aa2 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 5 Aug 2024 17:55:57 +0200 Subject: [PATCH 01/74] Python docstrings tests: don't test for CellmlElementType. --- tests/bindings/python/test_docstrings.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/bindings/python/test_docstrings.py b/tests/bindings/python/test_docstrings.py index a3b63037d..64eb54222 100644 --- a/tests/bindings/python/test_docstrings.py +++ b/tests/bindings/python/test_docstrings.py @@ -13,7 +13,7 @@ def test_docstrings(self): # Scan for missing or empty docstrings def scan(root, missing, prefix=''): prefix += root.__name__ - if not root.__doc__: + if not root.__doc__ and root.__name__ != 'CellmlElementType': missing.append(prefix) prefix += '.' # Scan children, using dict instead of dir to avoid inherited From 0207ff9d9d71a4a492c710dca22c5ba3172e4a8e Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 12 Jul 2024 14:57:17 +1200 Subject: [PATCH 02/74] Code generator: use different arrays for constants, computed constants, and algebraic variables. --- src/analyser.cpp | 13 +- src/analyserequation.cpp | 49 ++++- src/analyserequation_p.h | 6 +- src/analysermodel.cpp | 68 +++++- src/analysermodel_p.h | 4 +- src/api/libcellml/analyserequation.h | 55 +++-- src/api/libcellml/analysermodel.h | 86 ++++++-- src/api/libcellml/generatorprofile.h | 134 ++++++++++-- src/bindings/interface/analyserequation.i | 21 +- src/bindings/interface/analysermodel.i | 30 ++- src/bindings/interface/generatorprofile.i | 44 +++- src/bindings/javascript/analyserequation.cpp | 9 +- src/bindings/javascript/analysermodel.cpp | 12 +- src/bindings/javascript/generatorprofile.cpp | 16 +- src/debug.cpp | 37 +++- src/generator.cpp | 196 ++++++++++-------- src/generator_p.h | 2 + src/generatorprofile.cpp | 92 ++++++-- src/generatorprofilesha1values.h | 4 +- src/generatorprofiletools.cpp | 10 +- src/utilities.cpp | 32 +++ src/utilities.h | 22 ++ .../javascript/analyserequation.test.js | 25 ++- .../bindings/javascript/analysermodel.test.js | 20 +- .../javascript/analyservariable.test.js | 18 +- tests/bindings/javascript/generator.test.js | 6 +- .../javascript/generatorprofile.test.js | 36 +++- .../bindings/javascript/importsource.test.js | 2 +- tests/bindings/javascript/reset.test.js | 4 +- tests/bindings/javascript/variable.test.js | 4 +- tests/bindings/python/test_analyser.py | 23 +- .../bindings/python/test_generator_profile.py | 56 ++++- tests/coverage/coverage.cpp | 70 +++++-- tests/generator/generatorprofile.cpp | 34 ++- tests/resources/coverage/generator/model.c | 6 +- tests/resources/coverage/generator/model.h | 6 +- .../generator/model.implementation.out | 2 +- .../coverage/generator/model.interface.out | 2 +- .../generator/model.modified.profile.c | 6 +- .../generator/model.modified.profile.h | 6 +- .../generator/model.modified.profile.py | 6 +- tests/resources/coverage/generator/model.out | 2 +- tests/resources/coverage/generator/model.py | 6 +- .../algebraic_eqn_computed_var_on_rhs/model.c | 6 +- .../model.external.c | 6 +- .../model.external.h | 6 +- .../model.external.py | 6 +- .../algebraic_eqn_computed_var_on_rhs/model.h | 6 +- .../model.py | 6 +- .../algebraic_eqn_const_var_on_rhs/model.c | 6 +- .../algebraic_eqn_const_var_on_rhs/model.h | 6 +- .../algebraic_eqn_const_var_on_rhs/model.py | 6 +- .../algebraic_eqn_constant_on_rhs/model.c | 6 +- .../algebraic_eqn_constant_on_rhs/model.h | 6 +- .../algebraic_eqn_constant_on_rhs/model.py | 6 +- .../algebraic_eqn_derivative_on_rhs/model.c | 6 +- .../algebraic_eqn_derivative_on_rhs/model.h | 6 +- .../algebraic_eqn_derivative_on_rhs/model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../algebraic_eqn_state_var_on_rhs/model.c | 6 +- .../algebraic_eqn_state_var_on_rhs/model.h | 6 +- .../algebraic_eqn_state_var_on_rhs/model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../model.c | 6 +- .../model.external.c | 6 +- .../model.external.h | 6 +- .../model.external.py | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.one.external.c | 6 +- .../model.one.external.h | 6 +- .../model.one.external.py | 6 +- .../model.py | 6 +- .../model.three.externals.c | 6 +- .../model.three.externals.h | 6 +- .../model.three.externals.py | 6 +- .../model.two.externals.c | 6 +- .../model.two.externals.h | 6 +- .../model.two.externals.py | 6 +- .../model.not.ordered.c | 6 +- .../model.not.ordered.h | 6 +- .../model.not.ordered.py | 6 +- .../model.ordered.c | 6 +- .../model.ordered.h | 6 +- .../model.ordered.py | 6 +- .../algebraic_unknown_var_on_rhs/model.c | 6 +- .../algebraic_unknown_var_on_rhs/model.h | 6 +- .../algebraic_unknown_var_on_rhs/model.py | 6 +- .../generator/cell_geometry_model/model.c | 6 +- .../cell_geometry_model/model.external.c | 6 +- .../cell_geometry_model/model.external.h | 6 +- .../cell_geometry_model/model.external.py | 6 +- .../generator/cell_geometry_model/model.h | 6 +- .../generator/cell_geometry_model/model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../generator/cellml_slc_example/model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../cellml_unit_scaling_constant/model.c | 6 +- .../cellml_unit_scaling_constant/model.h | 6 +- .../cellml_unit_scaling_constant/model.py | 6 +- .../cellml_unit_scaling_rate/model.c | 6 +- .../cellml_unit_scaling_rate/model.h | 6 +- .../cellml_unit_scaling_rate/model.py | 6 +- .../cellml_unit_scaling_state/model.c | 6 +- .../cellml_unit_scaling_state/model.h | 6 +- .../cellml_unit_scaling_state/model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../cellml_unit_scaling_voi_direct/model.c | 6 +- .../cellml_unit_scaling_voi_direct/model.h | 6 +- .../cellml_unit_scaling_voi_direct/model.py | 6 +- .../cellml_unit_scaling_voi_indirect/model.c | 6 +- .../cellml_unit_scaling_voi_indirect/model.h | 6 +- .../cellml_unit_scaling_voi_indirect/model.py | 6 +- .../generator/dae_cellml_1_1_model/model.c | 6 +- .../generator/dae_cellml_1_1_model/model.h | 6 +- .../generator/dae_cellml_1_1_model/model.py | 6 +- .../generator/dependent_eqns/model.c | 6 +- .../generator/dependent_eqns/model.h | 6 +- .../generator/dependent_eqns/model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../model.algebraic.c | 6 +- .../model.algebraic.h | 6 +- .../model.algebraic.py | 6 +- .../model.c | 6 +- .../model.computed.constant.c | 6 +- .../model.computed.constant.h | 6 +- .../model.computed.constant.py | 6 +- .../model.constant.c | 6 +- .../model.constant.h | 6 +- .../model.constant.py | 6 +- .../model.dae.c | 6 +- .../model.dae.h | 6 +- .../model.dae.py | 6 +- .../model.dependent.algebraic.c | 6 +- .../model.dependent.algebraic.h | 6 +- .../model.dependent.algebraic.py | 6 +- .../model.dependent.computed.constant.c | 6 +- .../model.dependent.computed.constant.h | 6 +- .../model.dependent.computed.constant.py | 6 +- .../model.dependent.constant.c | 6 +- .../model.dependent.constant.h | 6 +- .../model.dependent.constant.py | 6 +- .../model.dependent.state.c | 6 +- .../model.dependent.state.h | 6 +- .../model.dependent.state.py | 6 +- .../model.external.c | 6 +- .../model.external.h | 6 +- .../model.external.py | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../model.state.c | 6 +- .../model.state.h | 6 +- .../model.state.py | 6 +- .../generator/noble_model_1962/model.c | 6 +- .../generator/noble_model_1962/model.h | 6 +- .../generator/noble_model_1962/model.py | 6 +- .../generator/ode_computed_var_on_rhs/model.c | 6 +- .../generator/ode_computed_var_on_rhs/model.h | 6 +- .../ode_computed_var_on_rhs/model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../generator/ode_const_var_on_rhs/model.c | 6 +- .../generator/ode_const_var_on_rhs/model.h | 6 +- .../generator/ode_const_var_on_rhs/model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../generator/ode_constant_on_rhs/model.c | 6 +- .../generator/ode_constant_on_rhs/model.h | 6 +- .../generator/ode_constant_on_rhs/model.py | 6 +- .../ode_constant_on_rhs_one_component/model.c | 6 +- .../ode_constant_on_rhs_one_component/model.h | 6 +- .../model.py | 6 +- .../ode_multiple_dependent_odes/model.c | 6 +- .../ode_multiple_dependent_odes/model.h | 6 +- .../ode_multiple_dependent_odes/model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../ode_multiple_odes_with_same_name/model.c | 6 +- .../ode_multiple_odes_with_same_name/model.h | 6 +- .../ode_multiple_odes_with_same_name/model.py | 6 +- .../generator/ode_unknown_var_on_rhs/model.c | 6 +- .../generator/ode_unknown_var_on_rhs/model.h | 6 +- .../generator/ode_unknown_var_on_rhs/model.py | 6 +- .../robertson_model_1966/model.dae.c | 6 +- .../robertson_model_1966/model.dae.h | 6 +- .../robertson_model_1966/model.dae.py | 6 +- .../robertson_model_1966/model.ode.c | 6 +- .../robertson_model_1966/model.ode.h | 6 +- .../robertson_model_1966/model.ode.py | 6 +- .../generator/sine_model_imports/model.c | 6 +- .../generator/sine_model_imports/model.h | 6 +- .../generator/sine_model_imports/model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- .../model.c | 6 +- .../model.h | 6 +- .../model.py | 6 +- 221 files changed, 1684 insertions(+), 666 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index 8b7c86948..23a693861 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -2502,8 +2502,8 @@ bool Analyser::AnalyserImpl::isStateRateBased(const AnalyserEquationPtr &equatio if ((dependency->type() == AnalyserEquation::Type::ODE) || ((dependency->type() == AnalyserEquation::Type::NLA) - && (dependency->variableCount() == 1) - && (dependency->variable(0)->type() == AnalyserVariable::Type::STATE)) + && (dependency->algebraicCount() == 1) + && (dependency->algebraic(0)->type() == AnalyserVariable::Type::STATE)) || isStateRateBased(dependency, checkedEquations)) { return true; } @@ -3121,7 +3121,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) if (type == AnalyserVariable::Type::STATE) { mModel->mPimpl->mStates.push_back(variable); } else { - mModel->mPimpl->mVariables.push_back(variable); + mModel->mPimpl->mAlgebraic.push_back(variable); } } @@ -3131,13 +3131,13 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Determine all the variables computed by the equation, as well as // whether the equation is an external one. - AnalyserVariablePtrs variables; + AnalyserVariablePtrs algebraic; auto externalEquation = true; for (const auto &unknownVariable : internalEquation->mUnknownVariables) { auto variable = aiv2avMappings[unknownVariable]; - variables.push_back(variable); + algebraic.push_back(variable); if (variable->type() != AnalyserVariable::Type::EXTERNAL) { externalEquation = false; @@ -3264,7 +3264,8 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) equationDependencies, internalEquation->mNlaSystemIndex, equationNlaSiblings, - variables); + {}, + algebraic); mModel->mPimpl->mEquations.push_back(equation); } diff --git a/src/analyserequation.cpp b/src/analyserequation.cpp index 228dd119e..7869e910d 100644 --- a/src/analyserequation.cpp +++ b/src/analyserequation.cpp @@ -33,7 +33,8 @@ void AnalyserEquation::AnalyserEquationImpl::populate(AnalyserEquation::Type typ const std::vector &dependencies, size_t nlaSystemIndex, const std::vector &nlaSiblings, - const std::vector &variables) + const std::vector &computedConstants, + const std::vector &algebraic) { mType = type; mAst = ast; @@ -41,14 +42,21 @@ void AnalyserEquation::AnalyserEquationImpl::populate(AnalyserEquation::Type typ std::copy(dependencies.begin(), dependencies.end(), back_inserter(mDependencies)); std::copy(nlaSiblings.begin(), nlaSiblings.end(), back_inserter(mNlaSiblings)); - std::copy(variables.begin(), variables.end(), back_inserter(mVariables)); + std::copy(computedConstants.begin(), computedConstants.end(), back_inserter(mComputedConstants)); + std::copy(algebraic.begin(), algebraic.end(), back_inserter(mAlgebraic)); } bool AnalyserEquation::AnalyserEquationImpl::isEmptyDependency(const AnalyserEquationWeakPtr &dependency) { - auto variables = dependency.lock()->variables(); + auto computedConstants = dependency.lock()->computedConstants(); - if (std::any_of(variables.begin(), variables.end(), [](const auto &v) { return v != nullptr; })) { + if (std::any_of(computedConstants.begin(), computedConstants.end(), [](const auto &v) { return v != nullptr; })) { + return false; + } + + auto algebraic = dependency.lock()->algebraic(); + + if (std::any_of(algebraic.begin(), algebraic.end(), [](const auto &v) { return v != nullptr; })) { return false; } @@ -153,23 +161,42 @@ bool AnalyserEquation::isStateRateBased() const return mPimpl->mIsStateRateBased; } -size_t AnalyserEquation::variableCount() const +size_t AnalyserEquation::computedConstantCount() const +{ + return mPimpl->mComputedConstants.size(); +} + +std::vector AnalyserEquation::computedConstants() const +{ + return mPimpl->mComputedConstants; +} + +AnalyserVariablePtr AnalyserEquation::computedConstant(size_t index) const +{ + if (index >= mPimpl->mComputedConstants.size()) { + return {}; + } + + return mPimpl->mComputedConstants[index]; +} + +size_t AnalyserEquation::algebraicCount() const { - return mPimpl->mVariables.size(); + return mPimpl->mAlgebraic.size(); } -std::vector AnalyserEquation::variables() const +std::vector AnalyserEquation::algebraic() const { - return mPimpl->mVariables; + return mPimpl->mAlgebraic; } -AnalyserVariablePtr AnalyserEquation::variable(size_t index) const +AnalyserVariablePtr AnalyserEquation::algebraic(size_t index) const { - if (index >= mPimpl->mVariables.size()) { + if (index >= mPimpl->mAlgebraic.size()) { return {}; } - return mPimpl->mVariables[index]; + return mPimpl->mAlgebraic[index]; } } // namespace libcellml diff --git a/src/analyserequation_p.h b/src/analyserequation_p.h index 79d9fa63a..ae3e576af 100644 --- a/src/analyserequation_p.h +++ b/src/analyserequation_p.h @@ -35,7 +35,8 @@ struct AnalyserEquation::AnalyserEquationImpl size_t mNlaSystemIndex; std::vector mNlaSiblings; bool mIsStateRateBased = false; - std::vector mVariables; + std::vector mComputedConstants; + std::vector mAlgebraic; static AnalyserEquationPtr create(); @@ -44,7 +45,8 @@ struct AnalyserEquation::AnalyserEquationImpl const std::vector &dependencies, size_t nlaSystemIndex, const std::vector &nlaSiblings, - const std::vector &variables); + const std::vector &computedConstants, + const std::vector &algebraic); static bool isEmptyDependency(const AnalyserEquationWeakPtr &dependency); diff --git a/src/analysermodel.cpp b/src/analysermodel.cpp index 1931ca389..459b4795b 100644 --- a/src/analysermodel.cpp +++ b/src/analysermodel.cpp @@ -121,31 +121,85 @@ AnalyserVariablePtr AnalyserModel::state(size_t index) const return mPimpl->mStates[index]; } -size_t AnalyserModel::variableCount() const +size_t AnalyserModel::constantCount() const { if (!isValid()) { return 0; } - return mPimpl->mVariables.size(); + return mPimpl->mConstants.size(); } -std::vector AnalyserModel::variables() const +std::vector AnalyserModel::constants() const { if (!isValid()) { return {}; } - return mPimpl->mVariables; + return mPimpl->mConstants; } -AnalyserVariablePtr AnalyserModel::variable(size_t index) const +AnalyserVariablePtr AnalyserModel::constant(size_t index) const { - if (!isValid() || (index >= mPimpl->mVariables.size())) { + if (!isValid() || (index >= mPimpl->mConstants.size())) { return {}; } - return mPimpl->mVariables[index]; + return mPimpl->mConstants[index]; +} + +size_t AnalyserModel::computedConstantCount() const +{ + if (!isValid()) { + return 0; + } + + return mPimpl->mComputedConstants.size(); +} + +std::vector AnalyserModel::computedConstants() const +{ + if (!isValid()) { + return {}; + } + + return mPimpl->mComputedConstants; +} + +AnalyserVariablePtr AnalyserModel::computedConstant(size_t index) const +{ + if (!isValid() || (index >= mPimpl->mComputedConstants.size())) { + return {}; + } + + return mPimpl->mComputedConstants[index]; +} + +size_t AnalyserModel::algebraicCount() const +{ + if (!isValid()) { + return 0; + } + + return mPimpl->mAlgebraic.size(); +} + +std::vector AnalyserModel::algebraic() const +{ + if (!isValid()) { + return {}; + } + + return mPimpl->mAlgebraic; +} + +AnalyserVariablePtr AnalyserModel::algebraic(size_t index) const +{ + if (!isValid() || (index >= mPimpl->mAlgebraic.size())) { + return {}; + } + + return mPimpl->mAlgebraic[index]; } size_t AnalyserModel::equationCount() const diff --git a/src/analysermodel_p.h b/src/analysermodel_p.h index 2933e8a94..ae7d9709c 100644 --- a/src/analysermodel_p.h +++ b/src/analysermodel_p.h @@ -35,7 +35,9 @@ struct AnalyserModel::AnalyserModelImpl AnalyserVariablePtr mVoi; std::vector mStates; - std::vector mVariables; + std::vector mConstants; + std::vector mComputedConstants; + std::vector mAlgebraic; std::vector mEquations; bool mNeedEqFunction = false; diff --git a/src/api/libcellml/analyserequation.h b/src/api/libcellml/analyserequation.h index d8a961e6b..b2ca20ca0 100644 --- a/src/api/libcellml/analyserequation.h +++ b/src/api/libcellml/analyserequation.h @@ -166,33 +166,62 @@ class LIBCELLML_EXPORT AnalyserEquation bool isStateRateBased() const; /** - * @brief Get the number of variables computed by this @ref AnalyserEquation. + * @brief Get the number of computed constants computed by this @ref AnalyserEquation. * - * Return the number of variables computed by this @ref AnalyserEquation. + * Return the number of computed constants computed by this @ref AnalyserEquation. * - * @return The number of variables. + * @return The number of computed constants. */ - size_t variableCount() const; + size_t computedConstantCount() const; /** - * @brief Get the variables computed by this @ref AnalyserEquation. + * @brief Get the computed constants computed by this @ref AnalyserEquation. * - * Return the variables computed by this @ref AnalyserEquation. + * Return the computed constants computed by this @ref AnalyserEquation. * - * @return The variables as a @c std::vector. + * @return The computed constants as a @c std::vector. */ - std::vector variables() const; + std::vector computedConstants() const; /** - * @brief Get the variable, at @p index, computed by this @ref AnalyserEquation. + * @brief Get the computed constant, at @p index, computed by this @ref AnalyserEquation. * - * Return the variable, at @p index, computed by this @ref AnalyserEquation. + * Return the computed constant, at @p index, computed by this @ref AnalyserEquation. * - * @param index The index of the variable to return. + * @param index The index of the computed constant to return. * - * @return The variable, at @p index, on success, @c nullptr on failure. + * @return The computed constant, at @p index, on success, @c nullptr on failure. */ - AnalyserVariablePtr variable(size_t index) const; + AnalyserVariablePtr computedConstant(size_t index) const; + + /** + * @brief Get the number of algebraic variables computed by this @ref AnalyserEquation. + * + * Return the number of algebraic variables computed by this @ref AnalyserEquation. + * + * @return The number of algebraic variables. + */ + size_t algebraicCount() const; + + /** + * @brief Get the algebraic variables computed by this @ref AnalyserEquation. + * + * Return the algebraic variables computed by this @ref AnalyserEquation. + * + * @return The algebraic variables as a @c std::vector. + */ + std::vector algebraic() const; + + /** + * @brief Get the algebraic variable, at @p index, computed by this @ref AnalyserEquation. + * + * Return the algebraic variable, at @p index, computed by this @ref AnalyserEquation. + * + * @param index The index of the algebraic variable to return. + * + * @return The algebraic variable, at @p index, on success, @c nullptr on failure. + */ + AnalyserVariablePtr algebraic(size_t index) const; private: AnalyserEquation(); /**< Constructor, @private. */ diff --git a/src/api/libcellml/analysermodel.h b/src/api/libcellml/analysermodel.h index e6358dcb7..d8e075bd7 100644 --- a/src/api/libcellml/analysermodel.h +++ b/src/api/libcellml/analysermodel.h @@ -142,34 +142,94 @@ class LIBCELLML_EXPORT AnalyserModel AnalyserVariablePtr state(size_t index) const; /** - * @brief Get the number of variables. + * @brief Get the number of constants. * - * Return the number of variables in the @ref AnalyserModel. + * Return the number of constants in the @ref AnalyserModel. * - * @return The number of variables. + * @return The number of constants. */ - size_t variableCount() const; + size_t constantCount() const; /** - * @brief Get the variables. + * @brief Get the constants. * - * Return the variables in the @ref AnalyserModel. + * Return the constants in the @ref AnalyserModel. * - * @return The variables as a @c std::vector. + * @return The constants as a @c std::vector. */ - std::vector variables() const; + std::vector constants() const; /** - * @brief Get the variable at @p index. + * @brief Get the constant at @p index. * - * Return the variable at the index @p index for the @ref AnalyserModel. + * Return the constant at the index @p index for the @ref AnalyserModel. * - * @param index The index of the variable to return. + * @param index The index of the constant to return. * - * @return The variable at the given @p index on success, @c nullptr on + * @return The constant at the given @p index on success, @c nullptr on * failure. */ - AnalyserVariablePtr variable(size_t index) const; + AnalyserVariablePtr constant(size_t index) const; + + /** + * @brief Get the number of computed constants. + * + * Return the number of computed constants in the @ref AnalyserModel. + * + * @return The number of computed constants. + */ + size_t computedConstantCount() const; + + /** + * @brief Get the computed constants. + * + * Return the computed constants in the @ref AnalyserModel. + * + * @return The computed constants as a @c std::vector. + */ + std::vector computedConstants() const; + + /** + * @brief Get the computed constant at @p index. + * + * Return the computed constant at the index @p index for the @ref AnalyserModel. + * + * @param index The index of the computed constant to return. + * + * @return The computed constant at the given @p index on success, @c nullptr on + * failure. + */ + AnalyserVariablePtr computedConstant(size_t index) const; + + /** + * @brief Get the number of algebraic variables. + * + * Return the number of algebraic variables in the @ref AnalyserModel. + * + * @return The number of algebraic variables. + */ + size_t algebraicCount() const; + + /** + * @brief Get the algebraic variables. + * + * Return the algebraic variables in the @ref AnalyserModel. + * + * @return The algebraic variables as a @c std::vector. + */ + std::vector algebraic() const; + + /** + * @brief Get the algebraic variable at @p index. + * + * Return the algebraic variable at the index @p index for the @ref AnalyserModel. + * + * @param index The index of the algebraic variable to return. + * + * @return The algebraic variable at the given @p index on success, @c nullptr on + * failure. + */ + AnalyserVariablePtr algebraic(size_t index) const; /** * @brief Get the number of equations. diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index 10335d24d..cb85018fb 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -2462,52 +2462,148 @@ class LIBCELLML_EXPORT GeneratorProfile void setImplementationStateCountString(const std::string &implementationStateCountString); /** - * @brief Get the @c std::string for the interface of the variable count + * @brief Get the @c std::string for the interface of the constant count * constant. * - * Return the @c std::string for the interface of the variable count + * Return the @c std::string for the interface of the constant count * constant. * - * @return The @c std::string for the interface of the variable count + * @return The @c std::string for the interface of the constant count * constant. */ - std::string interfaceVariableCountString() const; + std::string interfaceConstantCountString() const; /** - * @brief Set the @c std::string for the interface of the variable count + * @brief Set the @c std::string for the interface of the constant count * constant. * - * Set the @c std::string for the interface of the variable count constant. + * Set the @c std::string for the interface of the constant count constant. * - * @param interfaceVariableCountString The @c std::string to use for the - * interface of the variable count constant. + * @param interfaceConstantCountString The @c std::string to use for the + * interface of the constant count constant. */ - void setInterfaceVariableCountString(const std::string &interfaceVariableCountString); + void setInterfaceConstantCountString(const std::string &interfaceConstantCountString); /** - * @brief Get the @c std::string for the implementation of the variable + * @brief Get the @c std::string for the implementation of the constant * count constant. * - * Return the @c std::string for the implementation of the variable count + * Return the @c std::string for the implementation of the constant count * constant. * - * @return The @c std::string for the implementation of the variable count + * @return The @c std::string for the implementation of the constant count * constant. */ - std::string implementationVariableCountString() const; + std::string implementationConstantCountString() const; /** - * @brief Set the @c std::string for the implementation of the variable + * @brief Set the @c std::string for the implementation of the constant * count constant. * - * Set the @c std::string for the implementation of the variable count - * constant. To be useful, the string should contain the [VARIABLE_COUNT] + * Set the @c std::string for the implementation of the constant count + * constant. To be useful, the string should contain the [CONSTANT_COUNT] * tag, which will be replaced with the number of states in the model. * - * @param implementationVariableCountString The @c std::string to use for - * the implementation of the variable count constant. + * @param implementationConstantCountString The @c std::string to use for + * the implementation of the constant count constant. */ - void setImplementationVariableCountString(const std::string &implementationVariableCountString); + void setImplementationConstantCountString(const std::string &implementationConstantCountString); + + /** + * @brief Get the @c std::string for the interface of the computed constant count + * constant. + * + * Return the @c std::string for the interface of the computed constant count + * constant. + * + * @return The @c std::string for the interface of the computed constant count + * constant. + */ + std::string interfaceComputedConstantCountString() const; + + /** + * @brief Set the @c std::string for the interface of the computed constant count + * constant. + * + * Set the @c std::string for the interface of the computed constant count constant. + * + * @param interfaceComputedConstantCountString The @c std::string to use for the + * interface of the computed constant count constant. + */ + void setInterfaceComputedConstantCountString(const std::string &interfaceComputedConstantCountString); + + /** + * @brief Get the @c std::string for the implementation of the computed constant + * count constant. + * + * Return the @c std::string for the implementation of the computed constant count + * constant. + * + * @return The @c std::string for the implementation of the computed constant count + * constant. + */ + std::string implementationComputedConstantCountString() const; + + /** + * @brief Set the @c std::string for the implementation of the computed constant + * count constant. + * + * Set the @c std::string for the implementation of the computed constant count + * constant. To be useful, the string should contain the [COMPUTED_CONSTANT_COUNT] + * tag, which will be replaced with the number of states in the model. + * + * @param implementationComputedConstantCountString The @c std::string to use for + * the implementation of the computed constant count constant. + */ + void setImplementationComputedConstantCountString(const std::string &implementationComputedConstantCountString); + + /** + * @brief Get the @c std::string for the interface of the algebraic count + * constant. + * + * Return the @c std::string for the interface of the algebraic count + * constant. + * + * @return The @c std::string for the interface of the algebraic count + * constant. + */ + std::string interfaceAlgebraicCountString() const; + + /** + * @brief Set the @c std::string for the interface of the algebraic count + * constant. + * + * Set the @c std::string for the interface of the algebraic count constant. + * + * @param interfaceAlgebraicCountString The @c std::string to use for the + * interface of the algebraic count constant. + */ + void setInterfaceAlgebraicCountString(const std::string &interfaceAlgebraicCountString); + + /** + * @brief Get the @c std::string for the implementation of the algebraic + * count constant. + * + * Return the @c std::string for the implementation of the algebraic count + * constant. + * + * @return The @c std::string for the implementation of the algebraic count + * constant. + */ + std::string implementationAlgebraicCountString() const; + + /** + * @brief Set the @c std::string for the implementation of the algebraic + * count constant. + * + * Set the @c std::string for the implementation of the algebraic count + * constant. To be useful, the string should contain the [ALGEBRAIC_COUNT] + * tag, which will be replaced with the number of states in the model. + * + * @param implementationAlgebraicCountString The @c std::string to use for + * the implementation of the algebraic count constant. + */ + void setImplementationAlgebraicCountString(const std::string &implementationAlgebraicCountString); /** * @brief Get the @c std::string for the data structure for the variable diff --git a/src/bindings/interface/analyserequation.i b/src/bindings/interface/analyserequation.i index 208290c49..8cdce8a0d 100644 --- a/src/bindings/interface/analyserequation.i +++ b/src/bindings/interface/analyserequation.i @@ -43,14 +43,23 @@ %feature("docstring") libcellml::AnalyserEquation::isStateRateBased "Tests if this :class:`AnalyserEquation` object relies on states and/or rates."; -%feature("docstring") libcellml::AnalyserEquation::variableCount -"Returns the number of variables computed by this :class:`AnalyserEquation` object."; +%feature("docstring") libcellml::AnalyserEquation::computedConstantCount +"Returns the number of computed constants computed by this :class:`AnalyserEquation` object."; -%feature("docstring") libcellml::AnalyserEquation::variables -"Returns the variables computed by this :class:`AnalyserEquation` object."; +%feature("docstring") libcellml::AnalyserEquation::computedConstants +"Returns the computed constants computed by this :class:`AnalyserEquation` object."; -%feature("docstring") libcellml::AnalyserEquation::variable -"Returns the variable, at the given index, computed by this :class:`AnalyserEquation` object."; +%feature("docstring") libcellml::AnalyserEquation::computedConstant +"Returns the computed constant, at the given index, computed by this :class:`AnalyserEquation` object."; + +%feature("docstring") libcellml::AnalyserEquation::algebraicCount +"Returns the number of algebraic variables computed by this :class:`AnalyserEquation` object."; + +%feature("docstring") libcellml::AnalyserEquation::algebraic +"Returns the algebraic variables computed by this :class:`AnalyserEquation` object."; + +%feature("docstring") libcellml::AnalyserEquation::algebraic +"Returns the algebraic variable, at the given index, computed by this :class:`AnalyserEquation` object."; %{ #include "libcellml/analyserequation.h" diff --git a/src/bindings/interface/analysermodel.i b/src/bindings/interface/analysermodel.i index 704d3e2f4..8933692dd 100644 --- a/src/bindings/interface/analysermodel.i +++ b/src/bindings/interface/analysermodel.i @@ -34,14 +34,32 @@ %feature("docstring") libcellml::AnalyserModel::state "Returns the state, specified by index, contained by this :class:`AnalyserModel` object."; -%feature("docstring") libcellml::AnalyserModel::variableCount -"Returns the number of variables contained by this :class:`AnalyserModel` object."; +%feature("docstring") libcellml::AnalyserModel::constantCount +"Returns the number of constants contained by this :class:`AnalyserModel` object."; -%feature("docstring") libcellml::AnalyserModel::variables -"Returns the variables contained by this :class:`AnalyserModel` object."; +%feature("docstring") libcellml::AnalyserModel::constants +"Returns the constants contained by this :class:`AnalyserModel` object."; -%feature("docstring") libcellml::AnalyserModel::variable -"Returns the variable, specified by index, contained by this :class:`AnalyserModel` object."; +%feature("docstring") libcellml::AnalyserModel::constant +"Returns the constant, specified by index, contained by this :class:`AnalyserModel` object."; + +%feature("docstring") libcellml::AnalyserModel::computedConstantCount +"Returns the number of computed constants contained by this :class:`AnalyserModel` object."; + +%feature("docstring") libcellml::AnalyserModel::computedConstants +"Returns the computed constants contained by this :class:`AnalyserModel` object."; + +%feature("docstring") libcellml::AnalyserModel::computedConstant +"Returns the computed constant, specified by index, contained by this :class:`AnalyserModel` object."; + +%feature("docstring") libcellml::AnalyserModel::algebraicCount +"Returns the number of algebraic variables contained by this :class:`AnalyserModel` object."; + +%feature("docstring") libcellml::AnalyserModel::algebraic +"Returns the algebraic variables contained by this :class:`AnalyserModel` object."; + +%feature("docstring") libcellml::AnalyserModel::algebraic +"Returns the algebraic variable, specified by index, contained by this :class:`AnalyserModel` object."; %feature("docstring") libcellml::AnalyserModel::equationCount "Returns the number of equations contained by this :class:`AnalyserModel` object."; diff --git a/src/bindings/interface/generatorprofile.i b/src/bindings/interface/generatorprofile.i index 603ccd5b0..e8da17ba3 100644 --- a/src/bindings/interface/generatorprofile.i +++ b/src/bindings/interface/generatorprofile.i @@ -677,18 +677,44 @@ used respectively."; "Sets the string for the implementation of the state count constant. To be useful, the string should contain the tag, which will be replaced with the number of states in the model."; -%feature("docstring") libcellml::GeneratorProfile::interfaceVariableCountString -"Returns the string for the interface of the variable count constant."; +%feature("docstring") libcellml::GeneratorProfile::interfaceConstantCountString +"Returns the string for the interface of the constant count constant."; -%feature("docstring") libcellml::GeneratorProfile::setInterfaceVariableCountString -"Sets the string for the interface of the variable count constant."; +%feature("docstring") libcellml::GeneratorProfile::setInterfaceConstantCountString +"Sets the string for the interface of the constant count constant."; -%feature("docstring") libcellml::GeneratorProfile::implementationVariableCountString -"Returns the string for the implementation of the variable count constant."; +%feature("docstring") libcellml::GeneratorProfile::implementationConstantCountString +"Returns the string for the implementation of the constant count constant."; -%feature("docstring") libcellml::GeneratorProfile::setImplementationVariableCountString -"Sets the string for the implementation of the variable count constant. To be useful, the string should contain -the tag, which will be replaced with the number of states in the model."; +%feature("docstring") libcellml::GeneratorProfile::setImplementationConstantCountString +"Sets the string for the implementation of the constant count constant. To be useful, the string should contain +the tag, which will be replaced with the number of states in the model."; + +%feature("docstring") libcellml::GeneratorProfile::interfaceComputedConstantCountString +"Returns the string for the interface of the computed constant count constant."; + +%feature("docstring") libcellml::GeneratorProfile::setInterfaceComputedConstantCountString +"Sets the string for the interface of the computed constant count constant."; + +%feature("docstring") libcellml::GeneratorProfile::implementationComputedConstantCountString +"Returns the string for the implementation of the computed constant count constant."; + +%feature("docstring") libcellml::GeneratorProfile::setImplementationComputedConstantCountString +"Sets the string for the implementation of the computed constant count constant. To be useful, the string should contain +the tag, which will be replaced with the number of states in the model."; + +%feature("docstring") libcellml::GeneratorProfile::interfaceAlgebraicCountString +"Returns the string for the interface of the algebraic count constant."; + +%feature("docstring") libcellml::GeneratorProfile::setInterfaceAlgebraicCountString +"Sets the string for the interface of the algebraic count constant."; + +%feature("docstring") libcellml::GeneratorProfile::implementationAlgebraicCountString +"Returns the string for the implementation of the algebraic count constant."; + +%feature("docstring") libcellml::GeneratorProfile::setImplementationAlgebraicCountString +"Sets the string for the implementation of the algebraic count constant. To be useful, the string should contain +the tag, which will be replaced with the number of states in the model."; %feature("docstring") libcellml::GeneratorProfile::variableTypeObjectString "Returns the string for the data structure for the variable type object."; diff --git a/src/bindings/javascript/analyserequation.cpp b/src/bindings/javascript/analyserequation.cpp index d7579751f..c7a9daf69 100644 --- a/src/bindings/javascript/analyserequation.cpp +++ b/src/bindings/javascript/analyserequation.cpp @@ -45,9 +45,12 @@ EMSCRIPTEN_BINDINGS(libcellml_analyserequation) .function("nlaSiblings", &libcellml::AnalyserEquation::nlaSiblings) .function("nlaSibling", &libcellml::AnalyserEquation::nlaSibling) .function("isStateRateBased", &libcellml::AnalyserEquation::isStateRateBased) - .function("variableCount", &libcellml::AnalyserEquation::variableCount) - .function("variables", &libcellml::AnalyserEquation::variables) - .function("variable", &libcellml::AnalyserEquation::variable) + .function("computedConstantCount", &libcellml::AnalyserEquation::computedConstantCount) + .function("computedConstants", &libcellml::AnalyserEquation::computedConstants) + .function("computedConstant", &libcellml::AnalyserEquation::computedConstant) + .function("algebraicCount", &libcellml::AnalyserEquation::algebraicCount) + .function("algebraicVariables", select_overload() const>(&libcellml::AnalyserEquation::algebraic)) + .function("algebraicVariable", select_overload(&libcellml::AnalyserEquation::algebraic)) ; EM_ASM( diff --git a/src/bindings/javascript/analysermodel.cpp b/src/bindings/javascript/analysermodel.cpp index 87a74085f..3103e413a 100644 --- a/src/bindings/javascript/analysermodel.cpp +++ b/src/bindings/javascript/analysermodel.cpp @@ -45,9 +45,15 @@ EMSCRIPTEN_BINDINGS(libcellml_analysermodel) .function("stateCount", &libcellml::AnalyserModel::stateCount) .function("states", &libcellml::AnalyserModel::states) .function("state", &libcellml::AnalyserModel::state) - .function("variableCount", &libcellml::AnalyserModel::variableCount) - .function("variables", &libcellml::AnalyserModel::variables) - .function("variable", &libcellml::AnalyserModel::variable) + .function("constantCount", &libcellml::AnalyserModel::constantCount) + .function("constants", &libcellml::AnalyserModel::constants) + .function("constant", &libcellml::AnalyserModel::constant) + .function("computedConstantCount", &libcellml::AnalyserModel::computedConstantCount) + .function("computedConstants", &libcellml::AnalyserModel::computedConstants) + .function("computedConstant", &libcellml::AnalyserModel::computedConstant) + .function("algebraicCount", &libcellml::AnalyserModel::algebraicCount) + .function("algebraicVariables", select_overload() const>(&libcellml::AnalyserModel::algebraic)) + .function("algebraicVariable", select_overload(&libcellml::AnalyserModel::algebraic)) .function("equationCount", &libcellml::AnalyserModel::equationCount) .function("equations", &libcellml::AnalyserModel::equations) .function("equation", &libcellml::AnalyserModel::equation) diff --git a/src/bindings/javascript/generatorprofile.cpp b/src/bindings/javascript/generatorprofile.cpp index 41e4115fe..97a6ee651 100644 --- a/src/bindings/javascript/generatorprofile.cpp +++ b/src/bindings/javascript/generatorprofile.cpp @@ -251,10 +251,18 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setInterfaceStateCountString", &libcellml::GeneratorProfile::setInterfaceStateCountString) .function("implementationStateCountString", &libcellml::GeneratorProfile::implementationStateCountString) .function("setImplementationStateCountString", &libcellml::GeneratorProfile::setImplementationStateCountString) - .function("interfaceVariableCountString", &libcellml::GeneratorProfile::interfaceVariableCountString) - .function("setInterfaceVariableCountString", &libcellml::GeneratorProfile::setInterfaceVariableCountString) - .function("implementationVariableCountString", &libcellml::GeneratorProfile::implementationVariableCountString) - .function("setImplementationVariableCountString", &libcellml::GeneratorProfile::setImplementationVariableCountString) + .function("interfaceConstantCountString", &libcellml::GeneratorProfile::interfaceConstantCountString) + .function("setInterfaceConstantCountString", &libcellml::GeneratorProfile::setInterfaceConstantCountString) + .function("implementationConstantCountString", &libcellml::GeneratorProfile::implementationConstantCountString) + .function("setImplementationConstantCountString", &libcellml::GeneratorProfile::setImplementationConstantCountString) + .function("interfaceComputedConstantCountString", &libcellml::GeneratorProfile::interfaceComputedConstantCountString) + .function("setInterfaceComputedConstantCountString", &libcellml::GeneratorProfile::setInterfaceComputedConstantCountString) + .function("implementationComputedConstantCountString", &libcellml::GeneratorProfile::implementationComputedConstantCountString) + .function("setImplementationComputedConstantCountString", &libcellml::GeneratorProfile::setImplementationComputedConstantCountString) + .function("interfaceAlgebraicCountString", &libcellml::GeneratorProfile::interfaceAlgebraicCountString) + .function("setInterfaceAlgebraicCountString", &libcellml::GeneratorProfile::setInterfaceAlgebraicCountString) + .function("implementationAlgebraicCountString", &libcellml::GeneratorProfile::implementationAlgebraicCountString) + .function("setImplementationAlgebraicCountString", &libcellml::GeneratorProfile::setImplementationAlgebraicCountString) .function("variableTypeObjectString", &libcellml::GeneratorProfile::variableTypeObjectString) .function("setVariableTypeObjectString", &libcellml::GeneratorProfile::setVariableTypeObjectString) .function("variableOfIntegrationVariableTypeString", &libcellml::GeneratorProfile::variableOfIntegrationVariableTypeString) diff --git a/src/debug.cpp b/src/debug.cpp index b78d78853..179a80935 100644 --- a/src/debug.cpp +++ b/src/debug.cpp @@ -85,14 +85,24 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) Debug() << "\nType: " << AnalyserEquation::typeAsString(eqn->type()); - if (eqn->variableCount() != 0) { - Debug() << "\nVariables:"; + if (eqn->computedConstantCount() != 0) { + Debug() << "\nComputed constants:"; - for (const auto &var : eqn->variables()) { + for (const auto &var : eqn->computedConstants()) { Debug() << " - " << var->variable()->name(); } } else { - Debug() << "\nNo variables"; + Debug() << "\nNo computed constants"; + } + + if (eqn->algebraicCount() != 0) { + Debug() << "\nAlgebraic variables:"; + + for (const auto &var : eqn->algebraic()) { + Debug() << " - " << var->variable()->name(); + } + } else { + Debug() << "\nNo algebraic variables"; } if (eqn->dependencyCount() != 0) { @@ -102,7 +112,7 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) if (dep->ast() != nullptr) { Debug() << " - " << astAsCode(dep->ast()); } else if (dep->type() == AnalyserEquation::Type::EXTERNAL) { - Debug() << " - External equation for '" << dep->variable(0)->variable()->name() << "'"; + Debug() << " - External equation for '" << dep->algebraic(0)->variable()->name() << "'"; } else { Debug() << " - ??? [" << AnalyserEquation::typeAsString(dep->type()) << "]"; } @@ -119,7 +129,7 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) if (nlaSibling->ast() != nullptr) { Debug() << " - " << astAsCode(nlaSibling->ast()); } else if (nlaSibling->type() == AnalyserEquation::Type::EXTERNAL) { - Debug() << " - External equation for '" << nlaSibling->variable(0)->variable()->name() << "'"; + Debug() << " - External equation for '" << nlaSibling->algebraic(0)->variable()->name() << "'"; } else { Debug() << " - ??? [" << AnalyserEquation::typeAsString(nlaSibling->type()) << "]"; } @@ -133,12 +143,12 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) Debug() << "\n---------------------------------------[END]\n"; } -void printAnalyserModelVariables(const AnalyserModelPtr &model) +void printAnalyserModelVariables(const std::vector &variables) { size_t varNb = 0; - for (const auto &var : model->variables()) { - Debug() << "\n---------------------------------------[API variable " << ++varNb << "]"; + for (const auto &var : variables) { + Debug() << "\n---------------------------------------[API variable #" << ++varNb << "]"; Debug() << "\nName: " << var->variable()->name(); Debug() << "Type: " << AnalyserVariable::typeAsString(var->type()); @@ -149,7 +159,7 @@ void printAnalyserModelVariables(const AnalyserModelPtr &model) if (eqn->ast() != nullptr) { Debug() << " - " << astAsCode(eqn->ast()); } else if (eqn->type() == AnalyserEquation::Type::EXTERNAL) { - Debug() << " - External equation for '" << eqn->variable(0)->variable()->name() << "'"; + Debug() << " - External equation for '" << eqn->algebraic(0)->variable()->name() << "'"; } else { Debug() << " - ??? [" << AnalyserEquation::typeAsString(eqn->type()) << "]"; } @@ -160,6 +170,13 @@ void printAnalyserModelVariables(const AnalyserModelPtr &model) } } +void printAnalyserModelVariables(const AnalyserModelPtr &model) +{ + printAnalyserModelVariables(model->constants()); + printAnalyserModelVariables(model->computedConstants()); + printAnalyserModelVariables(model->algebraic()); +} + void printHistory(const History &history) { for (const auto &h : history) { diff --git a/src/generator.cpp b/src/generator.cpp index a018a6344..51a4e51b4 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -64,6 +64,22 @@ bool Generator::GeneratorImpl::modelHasNlas() const } } +AnalyserVariablePtr Generator::GeneratorImpl::doAnalyserVariable(const VariablePtr &variable, + const std::vector &variables) const +{ + AnalyserVariablePtr res; + + for (const auto &var : variables) { + if (mModel->areEquivalentVariables(variable, var->variable())) { + res = var; + + break; + } + } + + return res; +} + AnalyserVariablePtr Generator::GeneratorImpl::analyserVariable(const VariablePtr &variable) const { // Find and return the analyser variable associated with the given variable. @@ -76,39 +92,18 @@ AnalyserVariablePtr Generator::GeneratorImpl::analyserVariable(const VariablePtr && mModel->areEquivalentVariables(variable, modelVoiVariable)) { res = modelVoi; } else { - for (const auto &modelState : mModel->states()) { - if (mModel->areEquivalentVariables(variable, modelState->variable())) { - res = modelState; + res = doAnalyserVariable(variable, mModel->states()); - break; - } + if (res == nullptr) { + res = doAnalyserVariable(variable, mModel->constants()); } if (res == nullptr) { - // Normally, we would have: - // - // for (const auto &modelVariable : mModel->variables()) { - // if (mModel->areEquivalentVariables(variable, modelVariable->variable())) { - // res = modelVariable; - // - // break; - // } - // } - // - // but we always have variables, so llvm-cov will complain that the - // false branch of our for loop is never reached. The below code is - // a bit more verbose but at least it makes llvm-cov happy. - - auto modelVariables = mModel->variables(); - auto modelVariable = modelVariables.begin(); - - do { - if (mModel->areEquivalentVariables(variable, (*modelVariable)->variable())) { - res = *modelVariable; - } else { - ++modelVariable; - } - } while (res == nullptr); + res = doAnalyserVariable(variable, mModel->computedConstants()); + } + + if (res == nullptr) { + res = doAnalyserVariable(variable, mModel->algebraic()); } } @@ -293,64 +288,80 @@ void Generator::GeneratorImpl::addImplementationHeaderCode() void Generator::GeneratorImpl::addVersionAndLibcellmlVersionCode(bool interface) { - std::string versionAndLibcellmlCode; + std::string code; if ((interface && !mProfile->interfaceVersionString().empty()) || (!interface && !mProfile->implementationVersionString().empty())) { if (interface) { - versionAndLibcellmlCode += mProfile->interfaceVersionString(); + code += mProfile->interfaceVersionString(); } else { if (modifiedProfile()) { static const std::regex regEx("([0-9]+\\.[0-9]+\\.[0-9]+)"); - versionAndLibcellmlCode += std::regex_replace(mProfile->implementationVersionString(), regEx, "$1.post0"); + code += std::regex_replace(mProfile->implementationVersionString(), regEx, "$1.post0"); } else { - versionAndLibcellmlCode += mProfile->implementationVersionString(); + code += mProfile->implementationVersionString(); } } } if ((interface && !mProfile->interfaceLibcellmlVersionString().empty()) || (!interface && !mProfile->implementationLibcellmlVersionString().empty())) { - versionAndLibcellmlCode += interface ? - mProfile->interfaceLibcellmlVersionString() : - replace(mProfile->implementationLibcellmlVersionString(), - "[LIBCELLML_VERSION]", versionString()); + code += interface ? + mProfile->interfaceLibcellmlVersionString() : + replace(mProfile->implementationLibcellmlVersionString(), + "[LIBCELLML_VERSION]", versionString()); } - if (!versionAndLibcellmlCode.empty()) { + if (!code.empty()) { mCode += "\n"; } - mCode += versionAndLibcellmlCode; + mCode += code; } void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) { - std::string stateAndVariableCountCode; + std::string code; if (modelHasOdes() && ((interface && !mProfile->interfaceStateCountString().empty()) || (!interface && !mProfile->implementationStateCountString().empty()))) { - stateAndVariableCountCode += interface ? - mProfile->interfaceStateCountString() : - replace(mProfile->implementationStateCountString(), - "[STATE_COUNT]", std::to_string(mModel->stateCount())); + code += interface ? + mProfile->interfaceStateCountString() : + replace(mProfile->implementationStateCountString(), + "[STATE_COUNT]", std::to_string(mModel->stateCount())); } - if ((interface && !mProfile->interfaceVariableCountString().empty()) - || (!interface && !mProfile->implementationVariableCountString().empty())) { - stateAndVariableCountCode += interface ? - mProfile->interfaceVariableCountString() : - replace(mProfile->implementationVariableCountString(), - "[VARIABLE_COUNT]", std::to_string(mModel->variableCount())); + if ((interface && !mProfile->interfaceConstantCountString().empty()) + || (!interface && !mProfile->implementationConstantCountString().empty())) { + code += interface ? + mProfile->interfaceConstantCountString() : + replace(mProfile->implementationConstantCountString(), + "[CONSTANT_COUNT]", std::to_string(mModel->constantCount())); } - if (!stateAndVariableCountCode.empty()) { + if ((interface && !mProfile->interfaceComputedConstantCountString().empty()) + || (!interface && !mProfile->implementationComputedConstantCountString().empty())) { + code += interface ? + mProfile->interfaceComputedConstantCountString() : + replace(mProfile->implementationComputedConstantCountString(), + "[COMPUTED_CONSTANT_COUNT]", std::to_string(mModel->computedConstantCount())); + } + + if ((interface && !mProfile->interfaceAlgebraicCountString().empty()) + || (!interface && !mProfile->implementationAlgebraicCountString().empty())) { + code += interface ? + mProfile->interfaceAlgebraicCountString() : + replace(mProfile->implementationAlgebraicCountString(), + "[ALGEBRAIC_COUNT]", std::to_string(mModel->algebraicCount())); + } + + if (!code.empty()) { mCode += "\n"; } - mCode += stateAndVariableCountCode; + mCode += code; } void Generator::GeneratorImpl::addVariableTypeObjectCode() @@ -378,8 +389,16 @@ std::string Generator::GeneratorImpl::generateVariableInfoObjectCode(const std:: } } - for (const auto &variable : mModel->variables()) { - updateVariableInfoSizes(componentSize, nameSize, unitsSize, variable); + for (const auto &constant : mModel->constants()) { + updateVariableInfoSizes(componentSize, nameSize, unitsSize, constant); + } + + for (const auto &computedConstant : mModel->computedConstants()) { + updateVariableInfoSizes(componentSize, nameSize, unitsSize, computedConstant); + } + + for (const auto &algebraicVariable : mModel->algebraic()) { + updateVariableInfoSizes(componentSize, nameSize, unitsSize, algebraicVariable); } return replace(replace(replace(objectString, @@ -410,27 +429,27 @@ std::string Generator::GeneratorImpl::generateVariableInfoEntryCode(const std::s void Generator::GeneratorImpl::addInterfaceVoiStateAndVariableInfoCode() { - std::string interfaceVoiStateAndVariableInfoCode; + std::string code; if (modelHasOdes() && !mProfile->interfaceVoiInfoString().empty()) { - interfaceVoiStateAndVariableInfoCode += mProfile->interfaceVoiInfoString(); + code += mProfile->interfaceVoiInfoString(); } if (modelHasOdes() && !mProfile->interfaceStateInfoString().empty()) { - interfaceVoiStateAndVariableInfoCode += mProfile->interfaceStateInfoString(); + code += mProfile->interfaceStateInfoString(); } if (!mProfile->interfaceVariableInfoString().empty()) { - interfaceVoiStateAndVariableInfoCode += mProfile->interfaceVariableInfoString(); + code += mProfile->interfaceVariableInfoString(); } - if (!interfaceVoiStateAndVariableInfoCode.empty()) { + if (!code.empty()) { mCode += "\n"; } - mCode += interfaceVoiStateAndVariableInfoCode; + mCode += code; } void Generator::GeneratorImpl::addImplementationVoiInfoCode() @@ -495,8 +514,9 @@ void Generator::GeneratorImpl::addImplementationVariableInfoCode() && !mProfile->algebraicVariableTypeString().empty() && !mProfile->externalVariableTypeString().empty()) { std::string infoElementsCode; + auto variables = libcellml::variables(mModel); - for (const auto &variable : mModel->variables()) { + for (const auto &variable : variables) { if (!infoElementsCode.empty()) { infoElementsCode += mProfile->arrayElementSeparatorString() + "\n"; } @@ -694,26 +714,26 @@ void Generator::GeneratorImpl::addTrigonometricFunctionsCode() void Generator::GeneratorImpl::addInterfaceCreateDeleteArrayMethodsCode() { - std::string interfaceCreateDeleteArraysCode; + std::string code; if (modelHasOdes() && !mProfile->interfaceCreateStatesArrayMethodString().empty()) { - interfaceCreateDeleteArraysCode += mProfile->interfaceCreateStatesArrayMethodString(); + code += mProfile->interfaceCreateStatesArrayMethodString(); } if (!mProfile->interfaceCreateVariablesArrayMethodString().empty()) { - interfaceCreateDeleteArraysCode += mProfile->interfaceCreateVariablesArrayMethodString(); + code += mProfile->interfaceCreateVariablesArrayMethodString(); } if (!mProfile->interfaceDeleteArrayMethodString().empty()) { - interfaceCreateDeleteArraysCode += mProfile->interfaceDeleteArrayMethodString(); + code += mProfile->interfaceDeleteArrayMethodString(); } - if (!interfaceCreateDeleteArraysCode.empty()) { + if (!code.empty()) { mCode += "\n"; } - mCode += interfaceCreateDeleteArraysCode; + mCode += code; } void Generator::GeneratorImpl::addExternalVariableMethodTypeDefinitionCode() @@ -784,10 +804,10 @@ void Generator::GeneratorImpl::addNlaSystemsCode() && (std::find(handledNlaEquations.begin(), handledNlaEquations.end(), equation) == handledNlaEquations.end())) { std::string methodBody; auto i = MAX_SIZE_T; - auto variables = equation->variables(); - auto variablesSize = variables.size(); + auto variables = libcellml::variables(equation); + auto variablesCount = variables.size(); - for (i = 0; i < variablesSize; ++i) { + for (i = 0; i < variablesCount; ++i) { auto arrayString = (variables[i]->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : mProfile->variablesArrayString(); @@ -828,7 +848,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() methodBody = {}; - for (i = 0; i < variablesSize; ++i) { + for (i = 0; i < variablesCount; ++i) { auto arrayString = (variables[i]->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : mProfile->variablesArrayString(); @@ -844,11 +864,11 @@ void Generator::GeneratorImpl::addNlaSystemsCode() + mProfile->indentString() + replace(replace(mProfile->nlaSolveCallString(modelHasOdes()), "[INDEX]", convertToString(equation->nlaSystemIndex())), - "[SIZE]", convertToString(equation->variableCount())); + "[SIZE]", convertToString(variablesCount)); methodBody += newLineIfNeeded(); - for (i = 0; i < variablesSize; ++i) { + for (i = 0; i < variablesCount; ++i) { auto arrayString = (variables[i]->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : mProfile->variablesArrayString(); @@ -863,7 +883,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() mCode += newLineIfNeeded() + replace(replace(replace(mProfile->findRootMethodString(modelHasOdes()), "[INDEX]", convertToString(equation->nlaSystemIndex())), - "[SIZE]", convertToString(variablesSize)), + "[SIZE]", convertToString(variablesCount)), "[CODE]", generateMethodBodyCode(methodBody)); } } @@ -1744,9 +1764,11 @@ std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquatio // Generate the equation code itself, based on the equation type. + auto variables = libcellml::variables(equation); + switch (equation->type()) { case AnalyserEquation::Type::EXTERNAL: - for (const auto &variable : equation->variables()) { + for (const auto &variable : variables) { res += mProfile->indentString() + generateVariableNameCode(variable->variable()) + mProfile->equalityString() @@ -1786,35 +1808,35 @@ void Generator::GeneratorImpl::addInterfaceComputeModelMethodsCode() { auto interfaceInitialiseVariablesMethodString = mProfile->interfaceInitialiseVariablesMethodString(modelHasOdes(), mModel->hasExternalVariables()); - std::string interfaceComputeModelMethodsCode; + std::string code; if (!interfaceInitialiseVariablesMethodString.empty()) { - interfaceComputeModelMethodsCode += interfaceInitialiseVariablesMethodString; + code += interfaceInitialiseVariablesMethodString; } if (!mProfile->interfaceComputeComputedConstantsMethodString().empty()) { - interfaceComputeModelMethodsCode += mProfile->interfaceComputeComputedConstantsMethodString(); + code += mProfile->interfaceComputeComputedConstantsMethodString(); } auto interfaceComputeRatesMethodString = mProfile->interfaceComputeRatesMethodString(mModel->hasExternalVariables()); if (modelHasOdes() && !interfaceComputeRatesMethodString.empty()) { - interfaceComputeModelMethodsCode += interfaceComputeRatesMethodString; + code += interfaceComputeRatesMethodString; } auto interfaceComputeVariablesMethodString = mProfile->interfaceComputeVariablesMethodString(modelHasOdes(), mModel->hasExternalVariables()); if (!interfaceComputeVariablesMethodString.empty()) { - interfaceComputeModelMethodsCode += interfaceComputeVariablesMethodString; + code += interfaceComputeVariablesMethodString; } - if (!interfaceComputeModelMethodsCode.empty()) { + if (!code.empty()) { mCode += "\n"; } - mCode += interfaceComputeModelMethodsCode; + mCode += code; } void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(std::vector &remainingEquations) @@ -1834,8 +1856,9 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st // such an NLA system has only one solution. std::string methodBody; + auto variables = libcellml::variables(mModel); - for (const auto &variable : mModel->variables()) { + for (const auto &variable : variables) { switch (variable->type()) { case AnalyserVariable::Type::CONSTANT: methodBody += generateInitialisationCode(variable); @@ -1931,10 +1954,13 @@ void Generator::GeneratorImpl::addImplementationComputeRatesMethodCode(std::vect // NLA equation in case the rate is not on its own on either the LHS // or RHS of the equation. + auto variables = libcellml::variables(equation); + auto variablesCount = variables.size(); + if ((equation->type() == AnalyserEquation::Type::ODE) || ((equation->type() == AnalyserEquation::Type::NLA) - && (equation->variableCount() == 1) - && (equation->variable(0)->type() == AnalyserVariable::Type::STATE))) { + && (variablesCount == 1) + && (variables[0]->type() == AnalyserVariable::Type::STATE))) { methodBody += generateEquationCode(equation, remainingEquations); } } diff --git a/src/generator_p.h b/src/generator_p.h index 2ddb812e9..4f9165da5 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -44,6 +44,8 @@ struct Generator::GeneratorImpl bool modelHasOdes() const; bool modelHasNlas() const; + AnalyserVariablePtr doAnalyserVariable(const VariablePtr &variable, + const std::vector &variables) const; AnalyserVariablePtr analyserVariable(const VariablePtr &variable) const; double scalingFactor(const VariablePtr &variable) const; diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 1362bc387..39fb8c39c 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -184,8 +184,14 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mInterfaceStateCountString; std::string mImplementationStateCountString; - std::string mInterfaceVariableCountString; - std::string mImplementationVariableCountString; + std::string mInterfaceConstantCountString; + std::string mImplementationConstantCountString; + + std::string mInterfaceComputedConstantCountString; + std::string mImplementationComputedConstantCountString; + + std::string mInterfaceAlgebraicCountString; + std::string mImplementationAlgebraicCountString; std::string mVariableTypeObjectFamWoevString; std::string mVariableTypeObjectFamWevString; @@ -505,8 +511,14 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceStateCountString = "extern const size_t STATE_COUNT;\n"; mImplementationStateCountString = "const size_t STATE_COUNT = [STATE_COUNT];\n"; - mInterfaceVariableCountString = "extern const size_t VARIABLE_COUNT;\n"; - mImplementationVariableCountString = "const size_t VARIABLE_COUNT = [VARIABLE_COUNT];\n"; + mInterfaceConstantCountString = "extern const size_t CONSTANT_COUNT;\n"; + mImplementationConstantCountString = "const size_t CONSTANT_COUNT = [CONSTANT_COUNT];\n"; + + mInterfaceComputedConstantCountString = "extern const size_t COMPUTED_CONSTANT_COUNT;\n"; + mImplementationComputedConstantCountString = "const size_t COMPUTED_CONSTANT_COUNT = [COMPUTED_CONSTANT_COUNT];\n"; + + mInterfaceAlgebraicCountString = "extern const size_t ALGEBRAIC_COUNT;\n"; + mImplementationAlgebraicCountString = "const size_t ALGEBRAIC_COUNT = [ALGEBRAIC_COUNT];\n"; mVariableTypeObjectFamWoevString = "typedef enum {\n" " CONSTANT,\n" @@ -677,8 +689,8 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "}\n"; - mInterfaceComputeComputedConstantsMethodString = "void computeComputedConstants(double *variables);\n"; - mImplementationComputeComputedConstantsMethodString = "void computeComputedConstants(double *variables)\n" + mInterfaceComputeComputedConstantsMethodString = "void computeComputedConstants(double *computedConstants);\n"; + mImplementationComputeComputedConstantsMethodString = "void computeComputedConstants(double *computedConstants)\n" "{\n" "[CODE]" "}\n"; @@ -934,8 +946,14 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceStateCountString = ""; mImplementationStateCountString = "STATE_COUNT = [STATE_COUNT]\n"; - mInterfaceVariableCountString = ""; - mImplementationVariableCountString = "VARIABLE_COUNT = [VARIABLE_COUNT]\n"; + mInterfaceConstantCountString = ""; + mImplementationConstantCountString = "CONSTANT_COUNT = [CONSTANT_COUNT]\n"; + + mInterfaceComputedConstantCountString = ""; + mImplementationComputedConstantCountString = "COMPUTED_CONSTANT_COUNT = [COMPUTED_CONSTANT_COUNT]\n"; + + mInterfaceAlgebraicCountString = ""; + mImplementationAlgebraicCountString = "ALGEBRAIC_COUNT = [ALGEBRAIC_COUNT]\n"; mVariableTypeObjectFamWoevString = "\n" "class VariableType(Enum):\n" @@ -1074,7 +1092,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceComputeComputedConstantsMethodString = ""; mImplementationComputeComputedConstantsMethodString = "\n" - "def compute_computed_constants(variables):\n" + "def compute_computed_constants(computed_constants):\n" "[CODE]"; mInterfaceComputeRatesMethodWoevString = ""; @@ -2250,24 +2268,64 @@ void GeneratorProfile::setImplementationStateCountString(const std::string &impl mPimpl->mImplementationStateCountString = implementationStateCountString; } -std::string GeneratorProfile::interfaceVariableCountString() const +std::string GeneratorProfile::interfaceConstantCountString() const +{ + return mPimpl->mInterfaceConstantCountString; +} + +void GeneratorProfile::setInterfaceConstantCountString(const std::string &interfaceConstantCountString) +{ + mPimpl->mInterfaceConstantCountString = interfaceConstantCountString; +} + +std::string GeneratorProfile::implementationConstantCountString() const +{ + return mPimpl->mImplementationConstantCountString; +} + +void GeneratorProfile::setImplementationConstantCountString(const std::string &implementationConstantCountString) +{ + mPimpl->mImplementationConstantCountString = implementationConstantCountString; +} + +std::string GeneratorProfile::interfaceComputedConstantCountString() const +{ + return mPimpl->mInterfaceComputedConstantCountString; +} + +void GeneratorProfile::setInterfaceComputedConstantCountString(const std::string &interfaceComputedConstantCountString) +{ + mPimpl->mInterfaceComputedConstantCountString = interfaceComputedConstantCountString; +} + +std::string GeneratorProfile::implementationComputedConstantCountString() const +{ + return mPimpl->mImplementationComputedConstantCountString; +} + +void GeneratorProfile::setImplementationComputedConstantCountString(const std::string &implementationComputedConstantCountString) +{ + mPimpl->mImplementationComputedConstantCountString = implementationComputedConstantCountString; +} + +std::string GeneratorProfile::interfaceAlgebraicCountString() const { - return mPimpl->mInterfaceVariableCountString; + return mPimpl->mInterfaceAlgebraicCountString; } -void GeneratorProfile::setInterfaceVariableCountString(const std::string &interfaceVariableCountString) +void GeneratorProfile::setInterfaceAlgebraicCountString(const std::string &interfaceAlgebraicCountString) { - mPimpl->mInterfaceVariableCountString = interfaceVariableCountString; + mPimpl->mInterfaceAlgebraicCountString = interfaceAlgebraicCountString; } -std::string GeneratorProfile::implementationVariableCountString() const +std::string GeneratorProfile::implementationAlgebraicCountString() const { - return mPimpl->mImplementationVariableCountString; + return mPimpl->mImplementationAlgebraicCountString; } -void GeneratorProfile::setImplementationVariableCountString(const std::string &implementationVariableCountString) +void GeneratorProfile::setImplementationAlgebraicCountString(const std::string &implementationAlgebraicCountString) { - mPimpl->mImplementationVariableCountString = implementationVariableCountString; + mPimpl->mImplementationAlgebraicCountString = implementationAlgebraicCountString; } std::string GeneratorProfile::variableTypeObjectString(bool forDifferentialModel, diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 9216e6171..e99328e5a 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "1ac959303d5e8d6623cbe0979cb608ef48aff653"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "41f70a8d0486fdb3638b310814ebaa7d3ddd6771"; +static const char C_GENERATOR_PROFILE_SHA1[] = "9e017d3075c0036910fad2326986a996c466de5d"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "34bc02948f9f9939303facbb0a0c2b8428d4b4aa"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index 2dce65f31..4a1613b8d 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -442,8 +442,14 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->interfaceStateCountString() + generatorProfile->implementationStateCountString(); - profileContents += generatorProfile->interfaceVariableCountString() - + generatorProfile->implementationVariableCountString(); + profileContents += generatorProfile->interfaceConstantCountString() + + generatorProfile->implementationConstantCountString(); + + profileContents += generatorProfile->interfaceComputedConstantCountString() + + generatorProfile->implementationComputedConstantCountString(); + + profileContents += generatorProfile->interfaceAlgebraicCountString() + + generatorProfile->implementationAlgebraicCountString(); profileContents += generatorProfile->variableTypeObjectString(false, false); profileContents += generatorProfile->variableTypeObjectString(false, true); diff --git a/src/utilities.cpp b/src/utilities.cpp index 51cb29a65..f59b00d29 100644 --- a/src/utilities.cpp +++ b/src/utilities.cpp @@ -26,6 +26,8 @@ limitations under the License. #include #include +#include "libcellml/analyserequation.h" +#include "libcellml/analysermodel.h" #include "libcellml/component.h" #include "libcellml/importsource.h" #include "libcellml/model.h" @@ -1315,4 +1317,34 @@ XmlNodePtr mathmlChildNode(const XmlNodePtr &node, size_t index) return res; } +std::vector variables(const AnalyserModelPtr &model) +{ + auto res = model->constants(); + auto computedConstants = model->computedConstants(); + + if (!computedConstants.empty()) { + res.insert(res.end(), computedConstants.begin(), computedConstants.end()); + } + + auto algebraic = model->algebraic(); + + if (!algebraic.empty()) { + res.insert(res.end(), algebraic.begin(), algebraic.end()); + } + + return res; +} + +std::vector variables(const AnalyserEquationPtr &equation) +{ + auto res = equation->computedConstants(); + auto algebraic = equation->algebraic(); + + if (!algebraic.empty()) { + res.insert(res.end(), algebraic.begin(), algebraic.end()); + } + + return res; +} + } // namespace libcellml diff --git a/src/utilities.h b/src/utilities.h index cf3830c81..87beda8af 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -870,4 +870,26 @@ size_t mathmlChildCount(const XmlNodePtr &node); */ XmlNodePtr mathmlChildNode(const XmlNodePtr &node, size_t index); +/** + * @brief Return the variables in the given model. + * + * Return the variables in the given model. + * + * @param model The model for which we want the variables. + * + * @return The variables in the given model. + */ +std::vector variables(const AnalyserModelPtr &model); + +/** + * @brief Return the variables in the given equation. + * + * Return the variables in the given equation. + * + * @param equation The equation for which we want the variables. + * + * @return The variables in the given equation. + */ +std::vector variables(const AnalyserEquationPtr &equation); + } // namespace libcellml diff --git a/tests/bindings/javascript/analyserequation.test.js b/tests/bindings/javascript/analyserequation.test.js index 4f1a5cc31..7619bdebd 100644 --- a/tests/bindings/javascript/analyserequation.test.js +++ b/tests/bindings/javascript/analyserequation.test.js @@ -56,7 +56,7 @@ describe("Analyser Equation tests", () => { expect(eqn.dependencies().size()).toBe(0) }); test('Checking Analyser Equation dependency.', () => { - expect(eqn.dependency(0)).toBe(null) + expect(eqn.dependency(0)).toBeNull() }); test('Checking Analyser Equation nlaSystemIndex.', () => { expect(eqn.nlaSystemIndex()).toBe(4294967295) @@ -68,16 +68,25 @@ describe("Analyser Equation tests", () => { expect(eqn.nlaSiblings().size()).toBe(0) }); test('Checking Analyser Equation nlaSibling.', () => { - expect(eqn.nlaSibling(0)).toBe(null) + expect(eqn.nlaSibling(0)).toBeNull() }); - test('Checking Analyser Equation variableCount.', () => { - expect(eqn.variableCount()).toBe(1) + test('Checking Analyser Equation computedConstantCount.', () => { + expect(eqn.computedConstantCount()).toBe(0) }); - test('Checking Analyser Equation variables.', () => { - expect(eqn.variables().size()).toBe(1) + test('Checking Analyser Equation computedConstants.', () => { + expect(eqn.computedConstants().size()).toBe(0) }); - test('Checking Analyser Equation variable.', () => { - expect(eqn.variable(0).variable().name()).toBe("x") + test('Checking Analyser Equation computedConstant.', () => { + expect(eqn.computedConstant(0)).toBeNull() + }); + test('Checking Analyser Equation algebraicCount.', () => { + expect(eqn.algebraicCount()).toBe(1) + }); + test('Checking Analyser Equation algebraicVariables.', () => { + expect(eqn.algebraicVariables().size()).toBe(1) + }); + test('Checking Analyser Equation algebraicVariable.', () => { + expect(eqn.algebraicVariable(0).variable().name()).toBe("x") }); test('Checking Analyser Equation AST.', () => { expect(eqn.ast().value()).toBe("") diff --git a/tests/bindings/javascript/analysermodel.test.js b/tests/bindings/javascript/analysermodel.test.js index a84ad5e3d..c709d9368 100644 --- a/tests/bindings/javascript/analysermodel.test.js +++ b/tests/bindings/javascript/analysermodel.test.js @@ -61,10 +61,20 @@ describe("Analyser Model tests", () => { expect(am.states().size()).toBe(4) expect(am.state(2).variable().name()).toBe("m") }); - test('Checking Analyser Model variables related API.', () => { - expect(am.variableCount()).toBe(18) - expect(am.variables().size()).toBe(18) - expect(am.variable(2).variable().name()).toBe("i_K") + test('Checking Analyser Model constants related API.', () => { + expect(am.constantCount()).toBe(0) + expect(am.constants().size()).toBe(0) + expect(am.constant(2)).toBeNull() + }); + test('Checking Analyser Model computed constants related API.', () => { + expect(am.computedConstantCount()).toBe(0) + expect(am.computedConstants().size()).toBe(0) + expect(am.computedConstant(2)).toBeNull() + }); + test('Checking Analyser Model algebraic variables related API.', () => { + expect(am.algebraicCount()).toBe(18) + expect(am.algebraicVariables().size()).toBe(18) + expect(am.algebraicVariable(2).variable().name()).toBe("i_K") }); test('Checking Analyser Model need* API.', () => { expect(am.needEqFunction()).toBe(false) @@ -93,6 +103,6 @@ describe("Analyser Model tests", () => { expect(am.needAcothFunction()).toBe(false) }); test('Checking Analyser Model are equivalent variables.', () => { - expect(am.areEquivalentVariables(am.variable(2).variable(), am.variable(7).variable())).toBe(false) + expect(am.areEquivalentVariables(am.algebraicVariable(2).variable(), am.algebraicVariable(7).variable())).toBe(false) }); }) diff --git a/tests/bindings/javascript/analyservariable.test.js b/tests/bindings/javascript/analyservariable.test.js index 52b5ef749..6aa1f4f8d 100644 --- a/tests/bindings/javascript/analyservariable.test.js +++ b/tests/bindings/javascript/analyservariable.test.js @@ -37,35 +37,37 @@ describe("Analyser Variable tests", () => { am = a.model() - expect(am.variableCount()).toBe(18) + expect(am.constantCount()).toBe(0) + expect(am.computedConstantCount()).toBe(0) + expect(am.algebraicCount()).toBe(18) }); test('Checking Analyser Variable type.', () => { - const av = am.variable(0) + const av = am.algebraicVariable(0) expect(av.type().value).toBe(libcellml.AnalyserVariable.Type.ALGEBRAIC.value) expect(libcellml.AnalyserVariable.typeAsString(av.type())).toBe("algebraic") }); test('Checking Analyser Variable index.', () => { - const av = am.variable(7) + const av = am.algebraicVariable(7) expect(av.index()).toBe(7) }); test('Checking Analyser Variable initialising variable.', () => { - const av = am.variable(15) + const av = am.algebraicVariable(15) expect(av.initialisingVariable().name()).toBe("g_K") }); test('Checking Analyser Variable variable.', () => { - const av = am.variable(10) + const av = am.algebraicVariable(10) expect(av.variable().name()).toBe("alpha_m") }); test('Checking Analyser Equation equationCount.', () => { - const av = am.variable(14) + const av = am.algebraicVariable(14) expect(av.equationCount()).toBe(1) }); test('Checking Analyser Variable equations.', () => { - const av = am.variable(14) + const av = am.algebraicVariable(14) expect(av.equations().size()).toBe(1) }); test('Checking Analyser Variable equation.', () => { - const av = am.variable(14) + const av = am.algebraicVariable(14) expect(av.equation(0).type().value).toBe(libcellml.AnalyserEquation.Type.VARIABLE_BASED_CONSTANT.value) }); }) diff --git a/tests/bindings/javascript/generator.test.js b/tests/bindings/javascript/generator.test.js index 0fd13e18a..bd854e65f 100644 --- a/tests/bindings/javascript/generator.test.js +++ b/tests/bindings/javascript/generator.test.js @@ -43,7 +43,7 @@ describe("Generator tests", () => { a.analyseModel(m) - expect(g.model()).toBe(null) + expect(g.model()).toBeNull() g.setModel(a.model()) @@ -62,10 +62,10 @@ describe("Generator tests", () => { g.setModel(a.model()) const interface_lines = g.interfaceCode().split('\n') - expect(interface_lines.length).toBe(40) + expect(interface_lines.length).toBe(42) const implementation_lines = g.implementationCode().split('\n') - expect(implementation_lines.length).toBe(67) + expect(implementation_lines.length).toBe(69) const equation_line_1 = libcellml.Generator.equationCode(a.model().equation(0).ast()) expect(equation_line_1.length).toBe(14) diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index be6ff9f39..7c5bd368e 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -684,17 +684,41 @@ describe("GeneratorProfile tests", () => { x.setImplementationStateCountString("something") expect(x.implementationStateCountString()).toBe("something") }); - test("Checking GeneratorProfile.interfaceVariableCountString.", () => { + test("Checking GeneratorProfile.interfaceConstantCountString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceVariableCountString("something") - expect(x.interfaceVariableCountString()).toBe("something") + x.setInterfaceConstantCountString("something") + expect(x.interfaceConstantCountString()).toBe("something") }); - test("Checking GeneratorProfile.implementationVariableCountString.", () => { + test("Checking GeneratorProfile.implementationConstantCountString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationVariableCountString("something") - expect(x.implementationVariableCountString()).toBe("something") + x.setImplementationConstantCountString("something") + expect(x.implementationConstantCountString()).toBe("something") + }); + test("Checking GeneratorProfile.interfaceComputedConstantCountString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setInterfaceComputedConstantCountString("something") + expect(x.interfaceComputedConstantCountString()).toBe("something") + }); + test("Checking GeneratorProfile.implementationComputedConstantCountString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setImplementationComputedConstantCountString("something") + expect(x.implementationComputedConstantCountString()).toBe("something") + }); + test("Checking GeneratorProfile.interfaceAlgebraicCountString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setInterfaceAlgebraicCountString("something") + expect(x.interfaceAlgebraicCountString()).toBe("something") + }); + test("Checking GeneratorProfile.implementationAlgebraicCountString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setImplementationAlgebraicCountString("something") + expect(x.implementationAlgebraicCountString()).toBe("something") }); test("Checking GeneratorProfile.variableTypeObjectString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/javascript/importsource.test.js b/tests/bindings/javascript/importsource.test.js index e349be088..f3b48c307 100644 --- a/tests/bindings/javascript/importsource.test.js +++ b/tests/bindings/javascript/importsource.test.js @@ -34,7 +34,7 @@ describe("Import Source tests", () => { const iS = new libcellml.ImportSource() const m = new libcellml.Model() - expect(iS.model()).toBe(null) + expect(iS.model()).toBeNull() iS.setModel(m) diff --git a/tests/bindings/javascript/reset.test.js b/tests/bindings/javascript/reset.test.js index ab70a879b..72a905f3f 100644 --- a/tests/bindings/javascript/reset.test.js +++ b/tests/bindings/javascript/reset.test.js @@ -41,7 +41,7 @@ describe("Reset tests", () => { const r = new libcellml.Reset() const v = new libcellml.Variable() - expect(r.variable()).toBe(null) + expect(r.variable()).toBeNull() r.setVariable(v) expect(r.variable()).toStrictEqual(v) @@ -50,7 +50,7 @@ describe("Reset tests", () => { const r = new libcellml.Reset() const v = new libcellml.Variable() - expect(r.testVariable()).toBe(null) + expect(r.testVariable()).toBeNull() r.setTestVariable(v) expect(r.testVariable()).toStrictEqual(v) diff --git a/tests/bindings/javascript/variable.test.js b/tests/bindings/javascript/variable.test.js index 9dbc06c2f..a3d863b0d 100644 --- a/tests/bindings/javascript/variable.test.js +++ b/tests/bindings/javascript/variable.test.js @@ -70,7 +70,7 @@ describe("Variable tests", () => { const v = new libcellml.Variable("V") const u = new libcellml.Units("mV") - expect(v.units()).toBe(null) + expect(v.units()).toBeNull() v.setUnitsByName("A") @@ -82,7 +82,7 @@ describe("Variable tests", () => { v.removeUnits() - expect(v.units()).toBe(null) + expect(v.units()).toBeNull() v.delete() u.delete() diff --git a/tests/bindings/python/test_analyser.py b/tests/bindings/python/test_analyser.py index 654daf1a2..3895e4b40 100644 --- a/tests/bindings/python/test_analyser.py +++ b/tests/bindings/python/test_analyser.py @@ -115,9 +115,15 @@ def test_coverage(self): self.assertIsNotNone(am.states()) self.assertIsNotNone(am.state(3)) - self.assertEqual(17, am.variableCount()) - self.assertIsNotNone(am.variables()) - self.assertIsNotNone(am.variable(3)) + self.assertEqual(0, am.constantCount()) + self.assertIsNotNone(am.constants()) + self.assertIsNone(am.constant(3)) + self.assertEqual(0, am.computedConstantCount()) + self.assertIsNotNone(am.computedConstants()) + self.assertIsNone(am.computedConstant(3)) + self.assertEqual(17, am.algebraicCount()) + self.assertIsNotNone(am.algebraic()) + self.assertIsNotNone(am.algebraic(3)) self.assertEqual(16, am.equationCount()) self.assertIsNotNone(am.equations()) @@ -152,7 +158,7 @@ def test_coverage(self): # Ensure coverage for AnalyserVariable. - av = am.variable(3) + av = am.algebraic(3) self.assertEqual(AnalyserVariable.Type.CONSTANT, av.type()) self.assertEqual("constant", AnalyserVariable.typeAsString(av.type())) @@ -180,9 +186,12 @@ def test_coverage(self): self.assertIsNotNone(ae.nlaSiblings()) self.assertIsNone(ae.nlaSibling(0)) self.assertTrue(ae.isStateRateBased()) - self.assertEqual(1, ae.variableCount()) - self.assertIsNotNone(ae.variables()) - self.assertIsNotNone(ae.variable(0)) + self.assertEqual(0, ae.computedConstantCount()) + self.assertIsNotNone(ae.computedConstants()) + self.assertIsNone(ae.computedConstant(0)) + self.assertEqual(1, ae.algebraicCount()) + self.assertIsNotNone(ae.algebraic()) + self.assertIsNotNone(ae.algebraic(0)) # Check Analyser Equation type with invalid values. diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index f91a0645a..a3bedd3a0 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -761,7 +761,7 @@ def test_implementation_compute_computed_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void computeComputedConstants(double *variables)\n{\n[CODE]}\n', + self.assertEqual('void computeComputedConstants(double *computedConstants)\n{\n[CODE]}\n', g.implementationComputeComputedConstantsMethodString()) g.setImplementationComputeComputedConstantsMethodString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeComputedConstantsMethodString()) @@ -907,14 +907,32 @@ def test_implementation_state_info_string(self): g.setImplementationStateInfoString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationStateInfoString()) - def test_implementation_variable_count_string(self): + def test_implementation_constant_count_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('const size_t VARIABLE_COUNT = [VARIABLE_COUNT];\n', g.implementationVariableCountString()) - g.setImplementationVariableCountString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationVariableCountString()) + self.assertEqual('const size_t CONSTANT_COUNT = [CONSTANT_COUNT];\n', g.implementationConstantCountString()) + g.setImplementationConstantCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationConstantCountString()) + + def test_implementation_computed_constant_count_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('const size_t COMPUTED_CONSTANT_COUNT = [COMPUTED_CONSTANT_COUNT];\n', g.implementationComputedConstantCountString()) + g.setImplementationComputedConstantCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputedConstantCountString()) + + def test_implementation_algebraic_count_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('const size_t ALGEBRAIC_COUNT = [ALGEBRAIC_COUNT];\n', g.implementationAlgebraicCountString()) + g.setImplementationAlgebraicCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationAlgebraicCountString()) def test_implementation_variable_info_string(self): from libcellml import GeneratorProfile @@ -967,7 +985,7 @@ def test_interface_compute_computed_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void computeComputedConstants(double *variables);\n', + self.assertEqual('void computeComputedConstants(double *computedConstants);\n', g.interfaceComputeComputedConstantsMethodString()) g.setInterfaceComputeComputedConstantsMethodString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeComputedConstantsMethodString()) @@ -1115,14 +1133,32 @@ def test_interface_state_info_string(self): g.setInterfaceStateInfoString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceStateInfoString()) - def test_interface_variable_count_string(self): + def test_interface_constant_count_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('extern const size_t CONSTANT_COUNT;\n', g.interfaceConstantCountString()) + g.setInterfaceConstantCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceConstantCountString()) + + def test_interface_computed_constant_count_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('extern const size_t COMPUTED_CONSTANT_COUNT;\n', g.interfaceComputedConstantCountString()) + g.setInterfaceComputedConstantCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputedConstantCountString()) + + def test_interface_algebraic_count_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('extern const size_t VARIABLE_COUNT;\n', g.interfaceVariableCountString()) - g.setInterfaceVariableCountString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceVariableCountString()) + self.assertEqual('extern const size_t ALGEBRAIC_COUNT;\n', g.interfaceAlgebraicCountString()) + g.setInterfaceAlgebraicCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceAlgebraicCountString()) def test_interface_variable_info_string(self): from libcellml import GeneratorProfile diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 0b1b24495..5805d7803 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -452,9 +452,17 @@ TEST(Coverage, analyser) EXPECT_EQ(size_t(0), analyserModel->states().size()); EXPECT_EQ(nullptr, analyserModel->state(0)); - EXPECT_EQ(size_t(0), analyserModel->variableCount()); - EXPECT_EQ(size_t(0), analyserModel->variables().size()); - EXPECT_EQ(nullptr, analyserModel->variable(0)); + EXPECT_EQ(size_t(0), analyserModel->constantCount()); + EXPECT_EQ(size_t(0), analyserModel->constants().size()); + EXPECT_EQ(nullptr, analyserModel->constant(0)); + + EXPECT_EQ(size_t(0), analyserModel->computedConstantCount()); + EXPECT_EQ(size_t(0), analyserModel->computedConstants().size()); + EXPECT_EQ(nullptr, analyserModel->computedConstant(0)); + + EXPECT_EQ(size_t(0), analyserModel->algebraicCount()); + EXPECT_EQ(size_t(0), analyserModel->algebraic().size()); + EXPECT_EQ(nullptr, analyserModel->algebraic(0)); EXPECT_EQ(size_t(0), analyserModel->equationCount()); EXPECT_EQ(size_t(0), analyserModel->equations().size()); @@ -548,7 +556,7 @@ TEST(Coverage, analyserTypes) auto analyserModel = analyser->model(); EXPECT_EQ("algebraic", libcellml::AnalyserEquation::typeAsString(analyserModel->equation(0)->type())); - EXPECT_EQ("algebraic", libcellml::AnalyserVariable::typeAsString(analyserModel->variable(0)->type())); + EXPECT_EQ("algebraic", libcellml::AnalyserVariable::typeAsString(analyserModel->algebraic(0)->type())); } void checkAstTypeAsString(const libcellml::AnalyserEquationAstPtr &ast) @@ -582,7 +590,9 @@ TEST(Coverage, generator) EXPECT_EQ("dae", libcellml::AnalyserModel::typeAsString(analyserModel->type())); EXPECT_EQ(size_t(1), analyserModel->stateCount()); - EXPECT_EQ(size_t(209), analyserModel->variableCount()); + EXPECT_EQ(size_t(0), analyserModel->constantCount()); + EXPECT_EQ(size_t(0), analyserModel->computedConstantCount()); + EXPECT_EQ(size_t(209), analyserModel->algebraicCount()); EXPECT_EQ(size_t(203), analyserModel->equationCount()); EXPECT_NE(nullptr, analyserModel->voi()); @@ -594,8 +604,12 @@ TEST(Coverage, generator) EXPECT_NE(size_t(0), analyserModel->state(0)->equations().size()); EXPECT_NE(nullptr, analyserModel->state(0)->equation(0)); EXPECT_EQ(nullptr, analyserModel->state(analyserModel->stateCount())); - EXPECT_NE(nullptr, analyserModel->variable(0)); - EXPECT_EQ(nullptr, analyserModel->variable(analyserModel->variableCount())); + EXPECT_EQ(nullptr, analyserModel->constant(0)); + EXPECT_EQ(nullptr, analyserModel->constant(analyserModel->constantCount())); + EXPECT_EQ(nullptr, analyserModel->computedConstant(0)); + EXPECT_EQ(nullptr, analyserModel->computedConstant(analyserModel->computedConstantCount())); + EXPECT_NE(nullptr, analyserModel->algebraic(0)); + EXPECT_EQ(nullptr, analyserModel->algebraic(analyserModel->algebraicCount())); EXPECT_NE(nullptr, analyserModel->equation(199)); EXPECT_NE(size_t(0), analyserModel->equation(199)->dependencyCount()); EXPECT_NE(size_t(0), analyserModel->equation(199)->dependencies().size()); @@ -605,10 +619,14 @@ TEST(Coverage, generator) EXPECT_EQ(size_t(1), analyserModel->equation(199)->nlaSiblings().size()); EXPECT_NE(nullptr, analyserModel->equation(199)->nlaSibling(0)); EXPECT_EQ(nullptr, analyserModel->equation(199)->nlaSibling(analyserModel->equation(199)->nlaSiblingCount())); - EXPECT_NE(size_t(0), analyserModel->equation(199)->variableCount()); - EXPECT_NE(size_t(0), analyserModel->equation(199)->variables().size()); - EXPECT_NE(nullptr, analyserModel->equation(199)->variable(0)); - EXPECT_EQ(nullptr, analyserModel->equation(199)->variable(analyserModel->equation(199)->variableCount())); + EXPECT_EQ(size_t(0), analyserModel->equation(199)->computedConstantCount()); + EXPECT_EQ(size_t(0), analyserModel->equation(199)->computedConstants().size()); + EXPECT_EQ(nullptr, analyserModel->equation(199)->computedConstant(0)); + EXPECT_EQ(nullptr, analyserModel->equation(199)->computedConstant(analyserModel->equation(199)->computedConstantCount())); + EXPECT_NE(size_t(0), analyserModel->equation(199)->algebraicCount()); + EXPECT_NE(size_t(0), analyserModel->equation(199)->algebraic().size()); + EXPECT_NE(nullptr, analyserModel->equation(199)->algebraic(0)); + EXPECT_EQ(nullptr, analyserModel->equation(199)->algebraic(analyserModel->equation(199)->algebraicCount())); EXPECT_EQ(nullptr, analyserModel->equation(analyserModel->equationCount())); for (const auto &equation : analyserModel->equations()) { @@ -623,9 +641,21 @@ TEST(Coverage, generator) EXPECT_NE(nullptr, analyserModel->state(i)->initialisingVariable()); } - for (size_t i = 0; i < analyserModel->variableCount(); ++i) { + for (size_t i = 0; i < analyserModel->constantCount(); ++i) { + if ((i == 1) || (i == 2) || (i == 6) || (i == 18) || (i == 179) || (i == 180) || (i == 182) || (i == 205) || (i == 206)) { + EXPECT_TRUE(analyserModel->constant(i)->initialisingVariable() != nullptr); + } + } + + for (size_t i = 0; i < analyserModel->computedConstantCount(); ++i) { if ((i == 1) || (i == 2) || (i == 6) || (i == 18) || (i == 179) || (i == 180) || (i == 182) || (i == 205) || (i == 206)) { - EXPECT_TRUE(analyserModel->variable(i)->initialisingVariable() != nullptr); + EXPECT_TRUE(analyserModel->computedConstant(i)->initialisingVariable() != nullptr); + } + } + + for (size_t i = 0; i < analyserModel->algebraicCount(); ++i) { + if ((i == 1) || (i == 2) || (i == 6) || (i == 18) || (i == 179) || (i == 180) || (i == 182) || (i == 205) || (i == 206)) { + EXPECT_TRUE(analyserModel->algebraic(i)->initialisingVariable() != nullptr); } } @@ -683,7 +713,9 @@ TEST(Coverage, generator) profile->setImplementationStateCountString(""); - profile->setImplementationVariableCountString(""); + profile->setImplementationConstantCountString(""); + profile->setImplementationComputedConstantCountString(""); + profile->setImplementationAlgebraicCountString(""); profile->setVariableTypeObjectString(false, false, ""); profile->setVariableTypeObjectString(false, true, ""); @@ -758,8 +790,14 @@ TEST(Coverage, generator) profile->setInterfaceStateCountString(""); profile->setImplementationStateCountString(""); - profile->setInterfaceVariableCountString(""); - profile->setImplementationVariableCountString(""); + profile->setInterfaceConstantCountString(""); + profile->setImplementationConstantCountString(""); + + profile->setInterfaceComputedConstantCountString(""); + profile->setImplementationComputedConstantCountString(""); + + profile->setInterfaceAlgebraicCountString(""); + profile->setImplementationAlgebraicCountString(""); profile->setVariableTypeObjectString(false, false, ""); profile->setVariableTypeObjectString(false, true, ""); diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 479b29d23..46c2850ec 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -279,8 +279,14 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("extern const size_t STATE_COUNT;\n", generatorProfile->interfaceStateCountString()); EXPECT_EQ("const size_t STATE_COUNT = [STATE_COUNT];\n", generatorProfile->implementationStateCountString()); - EXPECT_EQ("extern const size_t VARIABLE_COUNT;\n", generatorProfile->interfaceVariableCountString()); - EXPECT_EQ("const size_t VARIABLE_COUNT = [VARIABLE_COUNT];\n", generatorProfile->implementationVariableCountString()); + EXPECT_EQ("extern const size_t CONSTANT_COUNT;\n", generatorProfile->interfaceConstantCountString()); + EXPECT_EQ("const size_t CONSTANT_COUNT = [CONSTANT_COUNT];\n", generatorProfile->implementationConstantCountString()); + + EXPECT_EQ("extern const size_t COMPUTED_CONSTANT_COUNT;\n", generatorProfile->interfaceComputedConstantCountString()); + EXPECT_EQ("const size_t COMPUTED_CONSTANT_COUNT = [COMPUTED_CONSTANT_COUNT];\n", generatorProfile->implementationComputedConstantCountString()); + + EXPECT_EQ("extern const size_t ALGEBRAIC_COUNT;\n", generatorProfile->interfaceAlgebraicCountString()); + EXPECT_EQ("const size_t ALGEBRAIC_COUNT = [ALGEBRAIC_COUNT];\n", generatorProfile->implementationAlgebraicCountString()); EXPECT_EQ("typedef enum {\n" " CONSTANT,\n" @@ -485,9 +491,9 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationInitialiseVariablesMethodString(true, true)); - EXPECT_EQ("void computeComputedConstants(double *variables);\n", + EXPECT_EQ("void computeComputedConstants(double *computedConstants);\n", generatorProfile->interfaceComputeComputedConstantsMethodString()); - EXPECT_EQ("void computeComputedConstants(double *variables)\n" + EXPECT_EQ("void computeComputedConstants(double *computedConstants)\n" "{\n" "[CODE]" "}\n", @@ -865,8 +871,14 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setInterfaceStateCountString(value); generatorProfile->setImplementationStateCountString(value); - generatorProfile->setInterfaceVariableCountString(value); - generatorProfile->setImplementationVariableCountString(value); + generatorProfile->setInterfaceConstantCountString(value); + generatorProfile->setImplementationConstantCountString(value); + + generatorProfile->setInterfaceComputedConstantCountString(value); + generatorProfile->setImplementationComputedConstantCountString(value); + + generatorProfile->setInterfaceAlgebraicCountString(value); + generatorProfile->setImplementationAlgebraicCountString(value); generatorProfile->setVariableTypeObjectString(false, false, value); generatorProfile->setVariableTypeObjectString(false, true, value); @@ -994,8 +1006,14 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->interfaceStateCountString()); EXPECT_EQ(value, generatorProfile->implementationStateCountString()); - EXPECT_EQ(value, generatorProfile->interfaceVariableCountString()); - EXPECT_EQ(value, generatorProfile->implementationVariableCountString()); + EXPECT_EQ(value, generatorProfile->interfaceConstantCountString()); + EXPECT_EQ(value, generatorProfile->implementationConstantCountString()); + + EXPECT_EQ(value, generatorProfile->interfaceComputedConstantCountString()); + EXPECT_EQ(value, generatorProfile->implementationComputedConstantCountString()); + + EXPECT_EQ(value, generatorProfile->interfaceAlgebraicCountString()); + EXPECT_EQ(value, generatorProfile->implementationAlgebraicCountString()); EXPECT_EQ(value, generatorProfile->variableTypeObjectString(false, false)); EXPECT_EQ(value, generatorProfile->variableTypeObjectString(false, true)); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 3d96745ba..eb07d205f 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 209; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 209; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; @@ -401,7 +403,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[0] = variables[1] == variables[2]; variables[3] = variables[1]/(variables[2] == variables[2]); diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 3ff486183..371d0cf0f 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index eefbce8eb..ec60b6b08 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -172,7 +172,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[0] = eq(variables[1], variables[2]); variables[3] = variables[1]/eq(variables[2], variables[2]); diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index e50441a8b..73818239f 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -9,6 +9,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 56c23a290..90dca2c5a 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0.post0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 209; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 209; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; @@ -401,7 +403,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[0] = variables[1] == variables[2]; variables[3] = variables[1]/(variables[2] == variables[2]); diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index dc602c289..9466150a4 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index e99214ce3..b14261b73 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 209 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 209 class VariableType(Enum): @@ -401,7 +403,7 @@ def initialise_variables(states, rates, variables): states[0] = 0.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[0] = eq_func(variables[1], variables[2]) variables[3] = variables[1]/eq_func(variables[2], variables[2]) variables[4] = neq_func(variables[1], variables[2]) diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index b68591e82..a6f174319 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -142,7 +142,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[0] = variables[1] == variables[2]; variables[3] = variables[1]/(variables[2] == variables[2]); diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 9e75327d1..1f84e1dfc 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 209 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 209 class VariableType(Enum): @@ -401,7 +403,7 @@ def initialise_variables(states, rates, variables): states[0] = 0.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[0] = eq_func(variables[1], variables[2]) variables[3] = variables[1]/eq_func(variables[2], variables[2]) variables[4] = neq_func(variables[1], variables[2]) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index af60dcddf..546eab6c1 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, @@ -36,7 +38,7 @@ void initialiseVariables(double *variables) variables[1] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[0] = variables[1]; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 75e9d7dfe..aea7852aa 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_eqn", ALGEBRAIC}, @@ -36,7 +38,7 @@ void initialiseVariables(double *variables, ExternalVariable externalVariable) variables[1] = externalVariable(variables, 1); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index 9c1fc0d54..e3fc1c9e3 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -31,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index e162bd368..acf2568cf 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -31,7 +33,7 @@ def initialise_variables(variables, external_variable): variables[1] = external_variable(variables, 1) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index 599f17050..ccf06f8d4 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -28,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index ace02c542..11a1d3565 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -30,7 +32,7 @@ def initialise_variables(variables): variables[1] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[0] = variables[1] diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index e4c39d4c7..98a5119e7 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, @@ -36,7 +38,7 @@ void initialiseVariables(double *variables) variables[1] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[0] = variables[1]; } diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index 599f17050..ccf06f8d4 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -28,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index 93b0b8698..145fc0879 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -30,7 +32,7 @@ def initialise_variables(variables): variables[1] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[0] = variables[1] diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index ed5b2779e..23a92bc97 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_component", COMPUTED_CONSTANT} @@ -35,7 +37,7 @@ void initialiseVariables(double *variables) variables[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index 32566495b..0ca7442cf 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -28,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index 76067ecc6..f2c1b3fa7 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): @@ -29,7 +31,7 @@ def initialise_variables(variables): variables[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 0be2751ba..513c8f0a9 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -55,7 +57,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index 9cbab2d88..ee190e0f5 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index ea246e37b..d6dfe896a 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -44,7 +46,7 @@ def initialise_variables(states, rates, variables): states[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index c76bbd6ef..eba334d85 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; @@ -55,7 +57,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index 9aad67f7a..d1084de7a 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 93e624191..506f62284 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -44,7 +46,7 @@ def initialise_variables(states, rates, variables): states[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index c974f5a06..81ab0a6dc 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -55,7 +57,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index 5a4e26be3..8b5e1fc7f 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 819c48815..945c837bd 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -44,7 +46,7 @@ def initialise_variables(states, rates, variables): states[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 942fa8c58..e79a9e696 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "second", "my_model", VARIABLE_OF_INTEGRATION}; @@ -55,7 +57,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index 6801dd9c0..e6c0ef1cc 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 186d408c8..699173962 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -44,7 +46,7 @@ def initialise_variables(states, rates, variables): states[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 0d9cfb7a8..c7cae1bd4 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 4; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 4; const VariableInfo VARIABLE_INFO[] = { {"b", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, @@ -69,7 +71,7 @@ void initialiseVariables(double *variables) variables[2] = 7.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index a9235ddb8..406e43a24 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 4; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 4; const VariableInfo VARIABLE_INFO[] = { {"b", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, @@ -41,7 +43,7 @@ void initialiseVariables(double *variables, ExternalVariable externalVariable) variables[3] = externalVariable(variables, 3); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index 9c1fc0d54..e3fc1c9e3 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -31,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 6122ce629..52f6a82aa 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 4 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 4 class VariableType(Enum): @@ -36,7 +38,7 @@ def initialise_variables(variables, external_variable): variables[3] = external_variable(variables, 3) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index 599f17050..ccf06f8d4 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -28,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 64e6fded5..e64d422e5 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 4 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 4 class VariableType(Enum): @@ -56,7 +58,7 @@ def initialise_variables(variables): variables[2] = 7.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index b8339db9e..0e950fa1f 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 3; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 3; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_system", ALGEBRAIC}, @@ -75,7 +77,7 @@ void initialiseVariables(double *variables) variables[2] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index 5c5224a4c..d09497bd0 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -28,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c index 21337829c..e722bff08 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 3; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 3; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_system", EXTERNAL}, @@ -72,7 +74,7 @@ void initialiseVariables(double *variables, ExternalVariable externalVariable) variables[0] = externalVariable(variables, 0); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h index 1313c3687..e1fdbe098 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -31,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py index 43e635b6d..89a57c41c 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 3 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 3 class VariableType(Enum): @@ -60,7 +62,7 @@ def initialise_variables(variables, external_variable): variables[0] = external_variable(variables, 0) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 2f54c8121..9125b7c1d 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 3 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 3 class VariableType(Enum): @@ -62,7 +64,7 @@ def initialise_variables(variables): variables[2] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index 837d3e0ec..a5ec7515f 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 3; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 3; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_system", EXTERNAL}, @@ -39,7 +41,7 @@ void initialiseVariables(double *variables, ExternalVariable externalVariable) variables[2] = externalVariable(variables, 2); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index 1313c3687..e1fdbe098 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -31,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index 5816ca029..2dde0e032 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 3 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 3 class VariableType(Enum): @@ -34,7 +36,7 @@ def initialise_variables(variables, external_variable): variables[2] = external_variable(variables, 2) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c index 392e8f3ad..b4213f7a3 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 3; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 3; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_system", EXTERNAL}, @@ -109,7 +111,7 @@ void initialiseVariables(double *variables, ExternalVariable externalVariable) variables[2] = externalVariable(variables, 2); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h index 1313c3687..e1fdbe098 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -31,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py index 34b77ef86..d18695e14 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 3 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 3 class VariableType(Enum): @@ -91,7 +93,7 @@ def initialise_variables(variables, external_variable): variables[2] = external_variable(variables, 2) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index 55630e011..002200921 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 6; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 6; const VariableInfo VARIABLE_INFO[] = { {"d", "dimensionless", "my_algebraic_system", ALGEBRAIC}, @@ -75,7 +77,7 @@ void initialiseVariables(double *variables) variables[5] = 5.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[3] = 3.0*variables[4]+variables[5]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index 5c5224a4c..d09497bd0 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -28,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 0fbf42a74..5b34036e4 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 6 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 6 class VariableType(Enum): @@ -62,7 +64,7 @@ def initialise_variables(variables): variables[5] = 5.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[3] = 3.0*variables[4]+variables[5] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index e887e28b8..7ee14bfeb 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 6; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 6; const VariableInfo VARIABLE_INFO[] = { {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT}, @@ -75,7 +77,7 @@ void initialiseVariables(double *variables) variables[4] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[0] = 3.0*variables[1]+variables[2]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index 5c5224a4c..d09497bd0 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -28,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 3295b1d2c..640f553c3 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 6 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 6 class VariableType(Enum): @@ -62,7 +64,7 @@ def initialise_variables(variables): variables[4] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[0] = 3.0*variables[1]+variables[2] diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index 817c6ff7b..7991acc69 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_component", COMPUTED_CONSTANT}, @@ -36,7 +38,7 @@ void initialiseVariables(double *variables) variables[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[1] = variables[0]; } diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index 32566495b..0ca7442cf 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -28,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index b2ae5ff20..a7b0a114c 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -30,7 +32,7 @@ def initialise_variables(variables): variables[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[1] = variables[0] diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index dc9b50fd8..02f1470c4 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 4; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 4; const VariableInfo VARIABLE_INFO[] = { {"vcell", "microlitre", "cell_geometry", COMPUTED_CONSTANT}, @@ -39,7 +41,7 @@ void initialiseVariables(double *variables) variables[2] = 0.0011; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[0] = 1000.0*3.14*variables[2]*variables[2]*variables[1]; variables[3] = 0.02*variables[0]; diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index b93bdb565..23c8e5b5b 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 4; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 4; const VariableInfo VARIABLE_INFO[] = { {"vcell", "microlitre", "cell_geometry", ALGEBRAIC}, @@ -39,7 +41,7 @@ void initialiseVariables(double *variables, ExternalVariable externalVariable) variables[2] = externalVariable(variables, 2); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 3664a6d38..be4c0a832 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -31,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 5dda92b0a..741f7235d 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 4 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 4 class VariableType(Enum): @@ -34,7 +36,7 @@ def initialise_variables(variables, external_variable): variables[2] = external_variable(variables, 2) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index aecf1d812..2eeadc793 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -28,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index 09f2093d3..b6844d13f 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 4 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 4 class VariableType(Enum): @@ -33,7 +35,7 @@ def initialise_variables(variables): variables[2] = 0.0011 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[0] = 1000.0*3.14*variables[2]*variables[2]*variables[1] variables[3] = 0.02*variables[0] diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 2a4a3782e..70dec9ba6 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; @@ -56,7 +58,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[1] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index acc99f2a4..5127bc9de 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 414b539eb..ed00088c5 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -45,7 +47,7 @@ def initialise_variables(states, rates, variables): states[1] = 0.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index 65742c972..657ee35e4 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 10 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 10 class VariableType(Enum): @@ -46,7 +48,7 @@ def initialise_variables(variables): variables[9] = 2902500.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[0] = variables[1]*(variables[2]*variables[3]-variables[4]*variables[5])/(variables[6]*variables[5]+variables[9]*variables[3]+variables[8]*variables[5]*variables[3]+variables[7]) diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index fe4a89bfc..67bf67f14 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = variables[0]; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index d683c7fb0..353681ed9 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 6e0d3a8da..ee8ef1478 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[0] = variables[0] -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 6a467f9f6..9131b2ba1 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 3; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 3; const VariableInfo VARIABLE_INFO[] = { {"k", "mM", "constants", CONSTANT}, @@ -37,7 +39,7 @@ void initialiseVariables(double *variables) variables[0] = 123.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[1] = variables[0]+variables[0]; variables[2] = 0.001*variables[0]+0.001*variables[0]; diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index d43c10c5a..7d11520a1 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -28,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index ce3805d20..2380d4c77 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 3 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 3 class VariableType(Enum): @@ -31,7 +33,7 @@ def initialise_variables(variables): variables[0] = 123.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[1] = variables[0]+variables[0] variables[2] = 0.001*variables[0]+0.001*variables[0] diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 7ad69ffe8..48c0c0e0c 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 123.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index d683c7fb0..353681ed9 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 74bcb203f..99005d82b 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[0] = 123.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 2c207a86e..1e434a624 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 123.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index d683c7fb0..353681ed9 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index bcf2cc6cc..67c70992c 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[0] = 123.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index 034ff677c..d84efc4cd 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t VARIABLE_COUNT = 0; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[1] = 0.001*789.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index 3137b91f1..aa242b8af 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index f07685af6..b60faccff 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -VARIABLE_COUNT = 0 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[1] = 0.001*789.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index ed97d14b4..fdd80b095 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; @@ -58,7 +60,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[1] = 0.001*variables[1]; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 05eed874d..28a98085d 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index bc6233809..f04a5b936 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -47,7 +49,7 @@ def initialise_variables(states, rates, variables): states[1] = 0.001*variables[1] -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index 60ab45f36..1f652c788 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t VARIABLE_COUNT = 0; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[1] = 5.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index caeb40bab..614cdc5ec 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index 25a75e71f..6dfca0a42 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -VARIABLE_COUNT = 0 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[1] = 5.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index bdaea3fb3..54994da7d 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 3; -const size_t VARIABLE_COUNT = 0; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -56,7 +58,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[2] = 11.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 63103f19b..0ae986111 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index bd6d5e2be..4bc1c304c 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 3 -VARIABLE_COUNT = 0 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): @@ -45,7 +47,7 @@ def initialise_variables(states, rates, variables): states[2] = 11.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 8d6be4763..3a1022aa7 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t VARIABLE_COUNT = 10; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 10; const VariableInfo VOI_INFO = {"t", "second", "main", VARIABLE_OF_INTEGRATION}; @@ -129,7 +131,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[1] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 0a6670a37..4b380a3b4 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 3dc413e02..fd86ef428 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -VARIABLE_COUNT = 10 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 10 class VariableType(Enum): @@ -105,7 +107,7 @@ def initialise_variables(states, rates, variables): states[1] = 0.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index f8c2b7877..6aa94c3bf 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"time", "second", "my_component", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 762e2e457..8387ea6e2 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index 21f76ea6b..cee82a74b 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[0] = 0.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 00801300e..29744dac7 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 33; -const size_t VARIABLE_COUNT = 217; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 217; const VariableInfo VOI_INFO = {"time", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -424,7 +426,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[32] = 0.00277; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[3] = variables[119]*variables[120]/variables[17]; variables[6] = variables[3]*log(variables[7]/variables[8]); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index b76a0a63a..91f60ad4e 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 5c73b4ca5..d21a0dd17 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 33 -VARIABLE_COUNT = 217 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 217 class VariableType(Enum): @@ -433,7 +435,7 @@ def initialise_variables(states, rates, variables): states[32] = 0.00277 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[3] = variables[119]*variables[120]/variables[17] variables[6] = variables[3]*log(variables[7]/variables[8]) variables[20] = 1.2 if gt_func(variables[1], 0.0) else 1.0 diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 55b5e8207..c473d0e8c 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 15; -const size_t VARIABLE_COUNT = 185; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 185; const VariableInfo VOI_INFO = {"time", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -375,7 +377,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[14] = 0.03889291759; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[0] = (variables[2] == 0.0)?1.07*(3.0*variables[1]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295))):(variables[2] == 1.0)?variables[3]*variables[1]/(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295)):1.07*29.0*variables[1]/(30.0*(1.0+0.7745*exp(-(29.0*variables[1]-24.5)/1.95))); variables[4] = variables[5]+variables[0]*(variables[6]-variables[5]); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index c5d5585fa..9c13c3f34 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index ae48f667d..c2cb44155 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 15 -VARIABLE_COUNT = 185 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 185 class VariableType(Enum): @@ -372,7 +374,7 @@ def initialise_variables(states, rates, variables): states[14] = 0.03889291759 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[0] = 1.07*(3.0*variables[1]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295))) if eq_func(variables[2], 0.0) else variables[3]*variables[1]/(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295)) if eq_func(variables[2], 1.0) else 1.07*29.0*variables[1]/(30.0*(1.0+0.7745*exp(-(29.0*variables[1]-24.5)/1.95))) variables[4] = variables[5]+variables[0]*(variables[6]-variables[5]) variables[25] = variables[26]+variables[0]*(variables[27]-variables[26]) if eq_func(variables[2], 0.0) else variables[30]+variables[0]*(variables[31]-variables[30]) if eq_func(variables[2], 1.0) else variables[28]+variables[0]*(variables[29]-variables[28]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index e3b336546..b148c0bbd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t VARIABLE_COUNT = 18; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 18; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -82,7 +84,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *vari variables[0] = externalVariable(voi, states, rates, variables, 0); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index 90f2f2d76..e1fb1b494 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -37,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 48c80dcdf..72dbf27cf 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -VARIABLE_COUNT = 18 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 18 class VariableType(Enum): @@ -84,7 +86,7 @@ def initialise_variables(voi, states, rates, variables, external_variable): variables[0] = external_variable(voi, states, rates, variables, 0) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 18cd26605..a30ed76d2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t VARIABLE_COUNT = 18; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 18; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -81,7 +83,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[3] = 0.325; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 65d01ca6f..8ef6fb89f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t VARIABLE_COUNT = 18; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 18; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -82,7 +84,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *vari variables[6] = externalVariable(voi, states, rates, variables, 6); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[8] = variables[5]-115.0; variables[14] = variables[5]+12.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index 90f2f2d76..e1fb1b494 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -37,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 638c26a9d..4e2c615a6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -VARIABLE_COUNT = 18 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 18 class VariableType(Enum): @@ -84,7 +86,7 @@ def initialise_variables(voi, states, rates, variables, external_variable): variables[6] = external_variable(voi, states, rates, variables, 6) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 10cd74872..f28ef90f4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t VARIABLE_COUNT = 18; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 18; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -81,7 +83,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *vari variables[4] = externalVariable(voi, states, rates, variables, 4); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index 90f2f2d76..e1fb1b494 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -37,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 0a44cad71..efb48bb7b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -VARIABLE_COUNT = 18 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 18 class VariableType(Enum): @@ -83,7 +85,7 @@ def initialise_variables(voi, states, rates, variables, external_variable): variables[4] = external_variable(voi, states, rates, variables, 4) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 6ddde8da1..f84acb2cd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t VARIABLE_COUNT = 18; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 18; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -516,7 +518,7 @@ void initialiseVariables(double *states, double *rates, double *variables) rates[3] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index a6105918a..18f278fee 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 3142e999b..b377d909c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -VARIABLE_COUNT = 18 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 18 class VariableType(Enum): @@ -459,7 +461,7 @@ def initialise_variables(states, rates, variables): rates[3] = 0.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 1d24bd440..3bff29098 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t VARIABLE_COUNT = 18; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 18; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -83,7 +85,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *vari variables[0] = externalVariable(voi, states, rates, variables, 0); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index 90f2f2d76..e1fb1b494 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -37,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 044d7d84d..b3482e4bc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -VARIABLE_COUNT = 18 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 18 class VariableType(Enum): @@ -85,7 +87,7 @@ def initialise_variables(voi, states, rates, variables, external_variable): variables[0] = external_variable(voi, states, rates, variables, 0) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 0a069ee84..8820f3fac 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t VARIABLE_COUNT = 18; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 18; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -82,7 +84,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *vari variables[5] = externalVariable(voi, states, rates, variables, 5); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index 90f2f2d76..e1fb1b494 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -37,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index d1744f67c..1906e26f0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -VARIABLE_COUNT = 18 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 18 class VariableType(Enum): @@ -84,7 +86,7 @@ def initialise_variables(voi, states, rates, variables, external_variable): variables[5] = external_variable(voi, states, rates, variables, 5) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 943d980c9..ec4314811 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t VARIABLE_COUNT = 18; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 18; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -81,7 +83,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *vari variables[4] = externalVariable(voi, states, rates, variables, 4); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index 90f2f2d76..e1fb1b494 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -37,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 5794985f2..eb9c6b8d0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -VARIABLE_COUNT = 18 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 18 class VariableType(Enum): @@ -83,7 +85,7 @@ def initialise_variables(voi, states, rates, variables, external_variable): variables[4] = external_variable(voi, states, rates, variables, 4) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 1d9663bea..8157734aa 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t VARIABLE_COUNT = 20; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 20; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -81,7 +83,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *vari variables[11] = externalVariable(voi, states, rates, variables, 11); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[7] = variables[6]-10.613; variables[9] = variables[6]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index 90f2f2d76..e1fb1b494 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -37,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 58ab6ce15..114074129 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -VARIABLE_COUNT = 20 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 20 class VariableType(Enum): @@ -83,7 +85,7 @@ def initialise_variables(voi, states, rates, variables, external_variable): variables[11] = external_variable(voi, states, rates, variables, 11) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[7] = variables[6]-10.613 variables[9] = variables[6]-115.0 variables[16] = variables[6]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index aaccf7ec0..d82480785 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 3; -const size_t VARIABLE_COUNT = 19; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 19; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -83,7 +85,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *vari variables[4] = externalVariable(voi, states, rates, variables, 4); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[7] = variables[6]-10.613; variables[9] = variables[6]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index 90f2f2d76..e1fb1b494 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -37,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 2caf7951d..cc74a6a43 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 3 -VARIABLE_COUNT = 19 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 19 class VariableType(Enum): @@ -85,7 +87,7 @@ def initialise_variables(voi, states, rates, variables, external_variable): variables[4] = external_variable(voi, states, rates, variables, 4) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[7] = variables[6]-10.613 variables[9] = variables[6]-115.0 variables[15] = variables[6]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index a6105918a..18f278fee 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 4ccccffa1..cdbfc277a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -VARIABLE_COUNT = 18 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 18 class VariableType(Enum): @@ -82,7 +84,7 @@ def initialise_variables(states, rates, variables): states[3] = 0.325 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 6b8cab063..4689c74e6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 3; -const size_t VARIABLE_COUNT = 19; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 19; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -81,7 +83,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *vari variables[10] = externalVariable(voi, states, rates, variables, 10); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index 90f2f2d76..e1fb1b494 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -37,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 670866666..771fbc441 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 3 -VARIABLE_COUNT = 19 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 19 class VariableType(Enum): @@ -83,7 +85,7 @@ def initialise_variables(voi, states, rates, variables, external_variable): variables[10] = external_variable(voi, states, rates, variables, 10) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[15] = variables[5]+12.0 diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index fcf26ac8f..af60ee489 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t VARIABLE_COUNT = 17; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 17; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -80,7 +82,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[3] = 0.01; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index 1f66de15d..6988d2d31 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 2f5b868b5..52a828364 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -VARIABLE_COUNT = 17 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 17 class VariableType(Enum): @@ -69,7 +71,7 @@ def initialise_variables(states, rates, variables): states[3] = 0.01 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 05a03e5a3..529cf1804 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index caeb40bab..614cdc5ec 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index d7af94139..ec7afe8e0 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 7501f479c..5d8747a40 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index 9aad67f7a..d1084de7a 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index eb791199c..e15d14089 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index 50fe9e1d4..59be2f295 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index caeb40bab..614cdc5ec 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 171d3eb75..5d5b92520 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index f2ccf698e..a5074645d 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index 9aad67f7a..d1084de7a 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 05e7479b1..801a2997d 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index fa52eb92d..c026c7404 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 0; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -52,7 +54,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index caeb40bab..614cdc5ec 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index 36a70b444..20c1034b0 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 0 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): @@ -41,7 +43,7 @@ def initialise_variables(states, rates, variables): states[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 7ff69acaa..07897e662 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 0; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; @@ -52,7 +54,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index 9aad67f7a..d1084de7a 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index 5dbb6e4a2..096a989a7 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 0 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): @@ -41,7 +43,7 @@ def initialise_variables(states, rates, variables): states[0] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 06889b8f3..d0ae43433 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t VARIABLE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -56,7 +58,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[1] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index a685abb66..b5625ea2d 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 4aec9e342..37a213fb2 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -VARIABLE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): @@ -45,7 +47,7 @@ def initialise_variables(states, rates, variables): states[1] = 0.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index b4132dcb8..627806b47 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t VARIABLE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; @@ -56,7 +58,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[1] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index 6ac98c1de..a559621fe 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 599f63c55..a020f5101 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -VARIABLE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): @@ -45,7 +47,7 @@ def initialise_variables(states, rates, variables): states[1] = 0.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 23a6527e4..40cc955ab 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t VARIABLE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -56,7 +58,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[1] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index 7b5c06ff3..2b904e6bc 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 07a516dd1..06b202ef8 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -VARIABLE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): @@ -45,7 +47,7 @@ def initialise_variables(states, rates, variables): states[1] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index 79d02f608..0f39593a5 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t VARIABLE_COUNT = 0; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[1] = 1.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index caeb40bab..614cdc5ec 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index b5e0efba7..eb04fc9df 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -VARIABLE_COUNT = 0 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[1] = 1.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index f1812a253..36df485fd 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t VARIABLE_COUNT = 5; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 5; const VariableInfo VOI_INFO = {"t", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; @@ -97,7 +99,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[1] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index 3dcbda5b4..e5229113e 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 553cb6f9b..9e6f0c27e 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -VARIABLE_COUNT = 5 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 5 class VariableType(Enum): @@ -76,7 +78,7 @@ def initialise_variables(states, rates, variables): states[1] = 0.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 6d01ea6ae..56108226b 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 3; -const size_t VARIABLE_COUNT = 4; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 4; const VariableInfo VOI_INFO = {"t", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; @@ -63,7 +65,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[2] = 0.0; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index 3dcbda5b4..e5229113e 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 3c0078a47..0f7a9c039 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 3 -VARIABLE_COUNT = 4 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 4 class VariableType(Enum): @@ -52,7 +54,7 @@ def initialise_variables(states, rates, variables): states[2] = 0.0 -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 991454955..5dbedca63 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 10; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 10; const VariableInfo VOI_INFO = {"x", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; @@ -69,7 +71,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = variables[1]; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index 58ad0cde8..442d67f1c 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index d2846546b..0feacef13 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 10 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 10 class VariableType(Enum): @@ -62,7 +64,7 @@ def initialise_variables(states, rates, variables): states[0] = variables[1] -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 1dc61a878..ccabbc6bb 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -8,7 +8,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t VARIABLE_COUNT = 10; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 10; const VariableInfo VARIABLE_INFO[] = { {"v", "fmol_per_sec", "SLC_template3_ss", ALGEBRAIC}, @@ -52,7 +54,7 @@ void initialiseVariables(double *variables, ExternalVariable externalVariable) variables[9] = externalVariable(variables, 9); } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 21c1b1569..0673bd2f6 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -7,7 +7,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { CONSTANT, @@ -31,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *variables, ExternalVariable externalVariable); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 655783796..90ace85bd 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -7,7 +7,9 @@ __version__ = "0.4.0" LIBCELLML_VERSION = "0.5.0" -VARIABLE_COUNT = 10 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 10 class VariableType(Enum): @@ -47,7 +49,7 @@ def initialise_variables(variables, external_variable): variables[9] = external_variable(variables, 9) -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 63c674fd8..4f6983da4 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -9,7 +9,9 @@ const char VERSION[] = "0.5.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t VARIABLE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "component_1", VARIABLE_OF_INTEGRATION}; @@ -54,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *variables) states[0] = variables[0]; } -void computeComputedConstants(double *variables) +void computeComputedConstants(double *computedConstants) { } diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index caeedf9c6..4db60c5e2 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -8,7 +8,9 @@ extern const char VERSION[]; extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; -extern const size_t VARIABLE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, @@ -34,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *variables); -void computeComputedConstants(double *variables); +void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 4e53eb945..929ca69ec 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -8,7 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -VARIABLE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): @@ -43,7 +45,7 @@ def initialise_variables(states, rates, variables): states[0] = variables[0] -def compute_computed_constants(variables): +def compute_computed_constants(computed_constants): pass From 329b01f5e9573cd8f607bffd878bb600da3ba3cc Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 7 Aug 2024 15:20:32 +0200 Subject: [PATCH 03/74] Generator: use different arrays for constants, computed constants, and algebraic variables for initialiseVariables(). --- src/generatorprofile.cpp | 24 +++++++++---------- src/generatorprofilesha1values.h | 4 ++-- .../bindings/python/test_generator_profile.py | 16 ++++++------- tests/generator/generatorprofile.cpp | 16 ++++++------- tests/resources/coverage/generator/model.c | 2 +- tests/resources/coverage/generator/model.h | 2 +- .../generator/model.implementation.out | 2 +- .../coverage/generator/model.interface.out | 2 +- .../generator/model.modified.profile.c | 2 +- .../generator/model.modified.profile.h | 2 +- .../generator/model.modified.profile.py | 2 +- tests/resources/coverage/generator/model.out | 2 +- tests/resources/coverage/generator/model.py | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.h | 2 +- .../model.py | 2 +- .../algebraic_eqn_const_var_on_rhs/model.c | 2 +- .../algebraic_eqn_const_var_on_rhs/model.h | 2 +- .../algebraic_eqn_const_var_on_rhs/model.py | 2 +- .../algebraic_eqn_constant_on_rhs/model.c | 2 +- .../algebraic_eqn_constant_on_rhs/model.h | 2 +- .../algebraic_eqn_constant_on_rhs/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs/model.h | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs/model.h | 2 +- .../algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.one.external.c | 2 +- .../model.one.external.h | 2 +- .../model.one.external.py | 2 +- .../model.py | 2 +- .../model.three.externals.c | 2 +- .../model.three.externals.h | 2 +- .../model.three.externals.py | 2 +- .../model.two.externals.c | 2 +- .../model.two.externals.h | 2 +- .../model.two.externals.py | 2 +- .../model.not.ordered.c | 2 +- .../model.not.ordered.h | 2 +- .../model.not.ordered.py | 2 +- .../model.ordered.c | 2 +- .../model.ordered.h | 2 +- .../model.ordered.py | 2 +- .../algebraic_unknown_var_on_rhs/model.c | 2 +- .../algebraic_unknown_var_on_rhs/model.h | 2 +- .../algebraic_unknown_var_on_rhs/model.py | 2 +- .../generator/cell_geometry_model/model.c | 2 +- .../cell_geometry_model/model.external.c | 2 +- .../cell_geometry_model/model.external.h | 2 +- .../cell_geometry_model/model.external.py | 2 +- .../generator/cell_geometry_model/model.h | 2 +- .../generator/cell_geometry_model/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/cellml_slc_example/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../cellml_unit_scaling_constant/model.c | 2 +- .../cellml_unit_scaling_constant/model.h | 2 +- .../cellml_unit_scaling_constant/model.py | 2 +- .../cellml_unit_scaling_rate/model.c | 2 +- .../cellml_unit_scaling_rate/model.h | 2 +- .../cellml_unit_scaling_rate/model.py | 2 +- .../cellml_unit_scaling_state/model.c | 2 +- .../cellml_unit_scaling_state/model.h | 2 +- .../cellml_unit_scaling_state/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../cellml_unit_scaling_voi_direct/model.c | 2 +- .../cellml_unit_scaling_voi_direct/model.h | 2 +- .../cellml_unit_scaling_voi_direct/model.py | 2 +- .../cellml_unit_scaling_voi_indirect/model.c | 2 +- .../cellml_unit_scaling_voi_indirect/model.h | 2 +- .../cellml_unit_scaling_voi_indirect/model.py | 2 +- .../generator/dae_cellml_1_1_model/model.c | 2 +- .../generator/dae_cellml_1_1_model/model.h | 2 +- .../generator/dae_cellml_1_1_model/model.py | 2 +- .../generator/dependent_eqns/model.c | 2 +- .../generator/dependent_eqns/model.h | 2 +- .../generator/dependent_eqns/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.algebraic.c | 2 +- .../model.algebraic.h | 2 +- .../model.algebraic.py | 2 +- .../model.c | 2 +- .../model.computed.constant.c | 2 +- .../model.computed.constant.h | 2 +- .../model.computed.constant.py | 2 +- .../model.constant.c | 2 +- .../model.constant.h | 2 +- .../model.constant.py | 2 +- .../model.dae.c | 2 +- .../model.dae.h | 2 +- .../model.dae.py | 2 +- .../model.dependent.algebraic.c | 2 +- .../model.dependent.algebraic.h | 2 +- .../model.dependent.algebraic.py | 2 +- .../model.dependent.computed.constant.c | 2 +- .../model.dependent.computed.constant.h | 2 +- .../model.dependent.computed.constant.py | 2 +- .../model.dependent.constant.c | 2 +- .../model.dependent.constant.h | 2 +- .../model.dependent.constant.py | 2 +- .../model.dependent.state.c | 2 +- .../model.dependent.state.h | 2 +- .../model.dependent.state.py | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.state.c | 2 +- .../model.state.h | 2 +- .../model.state.py | 2 +- .../generator/noble_model_1962/model.c | 2 +- .../generator/noble_model_1962/model.h | 2 +- .../generator/noble_model_1962/model.py | 2 +- .../generator/ode_computed_var_on_rhs/model.c | 2 +- .../generator/ode_computed_var_on_rhs/model.h | 2 +- .../ode_computed_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/ode_const_var_on_rhs/model.c | 2 +- .../generator/ode_const_var_on_rhs/model.h | 2 +- .../generator/ode_const_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/ode_constant_on_rhs/model.c | 2 +- .../generator/ode_constant_on_rhs/model.h | 2 +- .../generator/ode_constant_on_rhs/model.py | 2 +- .../ode_constant_on_rhs_one_component/model.c | 2 +- .../ode_constant_on_rhs_one_component/model.h | 2 +- .../model.py | 2 +- .../ode_multiple_dependent_odes/model.c | 2 +- .../ode_multiple_dependent_odes/model.h | 2 +- .../ode_multiple_dependent_odes/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../ode_multiple_odes_with_same_name/model.c | 2 +- .../ode_multiple_odes_with_same_name/model.h | 2 +- .../ode_multiple_odes_with_same_name/model.py | 2 +- .../generator/ode_unknown_var_on_rhs/model.c | 2 +- .../generator/ode_unknown_var_on_rhs/model.h | 2 +- .../generator/ode_unknown_var_on_rhs/model.py | 2 +- .../robertson_model_1966/model.dae.c | 2 +- .../robertson_model_1966/model.dae.h | 2 +- .../robertson_model_1966/model.dae.py | 2 +- .../robertson_model_1966/model.ode.c | 2 +- .../robertson_model_1966/model.ode.h | 2 +- .../robertson_model_1966/model.ode.py | 2 +- .../generator/sine_model_imports/model.c | 2 +- .../generator/sine_model_imports/model.h | 2 +- .../generator/sine_model_imports/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- 191 files changed, 217 insertions(+), 217 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 39fb8c39c..f69e51b92 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -665,26 +665,26 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " free(array);\n" "}\n"; - mInterfaceInitialiseVariablesMethodFamWoevString = "void initialiseVariables(double *variables);\n"; - mImplementationInitialiseVariablesMethodFamWoevString = "void initialiseVariables(double *variables)\n" + mInterfaceInitialiseVariablesMethodFamWoevString = "void initialiseVariables(double *constants);\n"; + mImplementationInitialiseVariablesMethodFamWoevString = "void initialiseVariables(double *constants)\n" "{\n" "[CODE]" "}\n"; - mInterfaceInitialiseVariablesMethodFamWevString = "void initialiseVariables(double *variables, ExternalVariable externalVariable);\n"; - mImplementationInitialiseVariablesMethodFamWevString = "void initialiseVariables(double *variables, ExternalVariable externalVariable)\n" + mInterfaceInitialiseVariablesMethodFamWevString = "void initialiseVariables(double *constants, ExternalVariable externalVariable);\n"; + mImplementationInitialiseVariablesMethodFamWevString = "void initialiseVariables(double *constants, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n"; - mInterfaceInitialiseVariablesMethodFdmWoevString = "void initialiseVariables(double *states, double *rates, double *variables);\n"; - mImplementationInitialiseVariablesMethodFdmWoevString = "void initialiseVariables(double *states, double *rates, double *variables)\n" + mInterfaceInitialiseVariablesMethodFdmWoevString = "void initialiseVariables(double *states, double *rates, double *constants);\n"; + mImplementationInitialiseVariablesMethodFdmWoevString = "void initialiseVariables(double *states, double *rates, double *constants)\n" "{\n" "[CODE]" "}\n"; - mInterfaceInitialiseVariablesMethodFdmWevString = "void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable);\n"; - mImplementationInitialiseVariablesMethodFdmWevString = "void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable)\n" + mInterfaceInitialiseVariablesMethodFdmWevString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable);\n"; + mImplementationInitialiseVariablesMethodFdmWevString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n"; @@ -1072,22 +1072,22 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceInitialiseVariablesMethodFamWoevString = ""; mImplementationInitialiseVariablesMethodFamWoevString = "\n" - "def initialise_variables(variables):\n" + "def initialise_variables(constants):\n" "[CODE]"; mInterfaceInitialiseVariablesMethodFamWevString = ""; mImplementationInitialiseVariablesMethodFamWevString = "\n" - "def initialise_variables(variables, external_variable):\n" + "def initialise_variables(constants, external_variable):\n" "[CODE]"; mInterfaceInitialiseVariablesMethodFdmWoevString = ""; mImplementationInitialiseVariablesMethodFdmWoevString = "\n" - "def initialise_variables(states, rates, variables):\n" + "def initialise_variables(states, rates, constants):\n" "[CODE]"; mInterfaceInitialiseVariablesMethodFdmWevString = ""; mImplementationInitialiseVariablesMethodFdmWevString = "\n" - "def initialise_variables(voi, states, rates, variables, external_variable):\n" + "def initialise_variables(voi, states, rates, constants, external_variable):\n" "[CODE]"; mInterfaceComputeComputedConstantsMethodString = ""; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index e99328e5a..8661315d2 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "9e017d3075c0036910fad2326986a996c466de5d"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "34bc02948f9f9939303facbb0a0c2b8428d4b4aa"; +static const char C_GENERATOR_PROFILE_SHA1[] = "12b8069d68c8c5ebe36b14a90c0bfb880d61b73d"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "ed70973a0cf394f386857d43bb4497b9b7f99e03"; } // namespace libcellml diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index a3bedd3a0..0d48a9a24 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -859,22 +859,22 @@ def test_implementation_initialise_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void initialiseVariables(double *variables)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double *constants)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(False, False)) g.setImplementationInitialiseVariablesMethodString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(False, False)) - self.assertEqual('void initialiseVariables(double *variables, ExternalVariable externalVariable)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double *constants, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(False, True)) g.setImplementationInitialiseVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(False, True)) - self.assertEqual('void initialiseVariables(double *states, double *rates, double *variables)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(True, False)) g.setImplementationInitialiseVariablesMethodString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(True, False)) - self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(True, True)) g.setImplementationInitialiseVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(True, True)) @@ -1086,22 +1086,22 @@ def test_interface_initialise_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void initialiseVariables(double *variables);\n', + self.assertEqual('void initialiseVariables(double *constants);\n', g.interfaceInitialiseVariablesMethodString(False, False)) g.setInterfaceInitialiseVariablesMethodString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(False, False)) - self.assertEqual('void initialiseVariables(double *variables, ExternalVariable externalVariable);\n', + self.assertEqual('void initialiseVariables(double *constants, ExternalVariable externalVariable);\n', g.interfaceInitialiseVariablesMethodString(False, True)) g.setInterfaceInitialiseVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(False, True)) - self.assertEqual('void initialiseVariables(double *states, double *rates, double *variables);\n', + self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants);\n', g.interfaceInitialiseVariablesMethodString(True, False)) g.setInterfaceInitialiseVariablesMethodString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(True, False)) - self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable);\n', + self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable);\n', g.interfaceInitialiseVariablesMethodString(True, True)) g.setInterfaceInitialiseVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(True, True)) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 46c2850ec..401b6dddd 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -459,33 +459,33 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationDeleteArrayMethodString()); - EXPECT_EQ("void initialiseVariables(double *variables);\n", + EXPECT_EQ("void initialiseVariables(double *constants);\n", generatorProfile->interfaceInitialiseVariablesMethodString(false, false)); - EXPECT_EQ("void initialiseVariables(double *variables)\n" + EXPECT_EQ("void initialiseVariables(double *constants)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationInitialiseVariablesMethodString(false, false)); - EXPECT_EQ("void initialiseVariables(double *variables, ExternalVariable externalVariable);\n", + EXPECT_EQ("void initialiseVariables(double *constants, ExternalVariable externalVariable);\n", generatorProfile->interfaceInitialiseVariablesMethodString(false, true)); - EXPECT_EQ("void initialiseVariables(double *variables, ExternalVariable externalVariable)\n" + EXPECT_EQ("void initialiseVariables(double *constants, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationInitialiseVariablesMethodString(false, true)); - EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *variables);\n", + EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants);\n", generatorProfile->interfaceInitialiseVariablesMethodString(true, false)); - EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *variables)\n" + EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationInitialiseVariablesMethodString(true, false)); - EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable);\n", + EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable);\n", generatorProfile->interfaceInitialiseVariablesMethodString(true, true)); - EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable)\n" + EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index eb07d205f..f42a71569 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -377,7 +377,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) variables[206] = u[1]; } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[1] = 1.0; variables[2] = 2.0; diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 371d0cf0f..33bedee9e 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index ec60b6b08..64b0e5915 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -146,7 +146,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) variables[206] = u[1]; } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[1] = 1.0; variables[2] = 2.0; diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index 73818239f..4efd4f2df 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -8,7 +8,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 90dca2c5a..105e8415b 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -377,7 +377,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) variables[206] = u[1]; } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[1] = 1.0; variables[2] = 2.0; diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 9466150a4..15b44e7e6 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -35,7 +35,7 @@ double * createStatesVector(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index b14261b73..178219f7e 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -378,7 +378,7 @@ def find_root_0(voi, states, rates, variables): variables[206] = u[1] -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[1] = 1.0 variables[2] = 2.0 variables[6] = 3.0 diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index a6f174319..a8b63dc14 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -116,7 +116,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) variables[206] = u[1]; } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[1] = 1.0; variables[2] = 2.0; diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 1f84e1dfc..ef2576587 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -378,7 +378,7 @@ def find_root_0(voi, states, rates, variables): variables[206] = u[1] -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[1] = 1.0 variables[2] = 2.0 variables[6] = 3.0 diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index 546eab6c1..54cf101ec 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -33,7 +33,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *variables) +void initialiseVariables(double *constants) { variables[1] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index aea7852aa..7cc4b66ed 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -33,7 +33,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *variables, ExternalVariable externalVariable) +void initialiseVariables(double *constants, ExternalVariable externalVariable) { variables[1] = externalVariable(variables, 1); } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index e3fc1c9e3..4e430ed5c 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *variables, ExternalVariable externalVariable); +void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index acf2568cf..db4e1a273 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -29,7 +29,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables, external_variable): +def initialise_variables(constants, external_variable): variables[1] = external_variable(variables, 1) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index ccf06f8d4..7be31b590 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -29,6 +29,6 @@ extern const VariableInfo VARIABLE_INFO[]; double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *variables); +void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index 11a1d3565..f5a242078 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -28,7 +28,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables): +def initialise_variables(constants): variables[1] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index 98a5119e7..b3bebf874 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -33,7 +33,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *variables) +void initialiseVariables(double *constants) { variables[1] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index ccf06f8d4..7be31b590 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -29,6 +29,6 @@ extern const VariableInfo VARIABLE_INFO[]; double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *variables); +void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index 145fc0879..d9e835d39 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -28,7 +28,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables): +def initialise_variables(constants): variables[1] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index 23a92bc97..218da9766 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -32,7 +32,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *variables) +void initialiseVariables(double *constants) { variables[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index 0ca7442cf..230086c60 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -29,6 +29,6 @@ extern const VariableInfo VARIABLE_INFO[]; double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *variables); +void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index f2c1b3fa7..a0f283790 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -27,7 +27,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables): +def initialise_variables(constants): variables[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 513c8f0a9..72996b13e 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -51,7 +51,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index ee190e0f5..b7c0c64e3 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index d6dfe896a..a7ae59d7c 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -41,7 +41,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index eba334d85..600e33650 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -51,7 +51,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index d1084de7a..be002fd71 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 506f62284..546587aa9 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -41,7 +41,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 81ab0a6dc..55b34a516 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -51,7 +51,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index 8b5e1fc7f..e1313e395 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 945c837bd..6ea7c7cd7 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -41,7 +41,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index e79a9e696..03905f281 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -51,7 +51,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index e6c0ef1cc..90ebf612d 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 699173962..866f33265 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -41,7 +41,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index c7cae1bd4..fdf043a00 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -63,7 +63,7 @@ void findRoot0(double *variables) variables[3] = u[0]; } -void initialiseVariables(double *variables) +void initialiseVariables(double *constants) { variables[3] = 1.0; variables[0] = 3.0; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index 406e43a24..300066fb2 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -35,7 +35,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *variables, ExternalVariable externalVariable) +void initialiseVariables(double *constants, ExternalVariable externalVariable) { variables[0] = 3.0; variables[1] = 5.0; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index e3fc1c9e3..4e430ed5c 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *variables, ExternalVariable externalVariable); +void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 52f6a82aa..2f516f834 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -31,7 +31,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables, external_variable): +def initialise_variables(constants, external_variable): variables[0] = 3.0 variables[1] = 5.0 variables[2] = 7.0 diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index ccf06f8d4..7be31b590 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -29,6 +29,6 @@ extern const VariableInfo VARIABLE_INFO[]; double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *variables); +void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index e64d422e5..3f07e38d5 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -51,7 +51,7 @@ def find_root_0(variables): variables[3] = u[0] -def initialise_variables(variables): +def initialise_variables(constants): variables[3] = 1.0 variables[0] = 3.0 variables[1] = 5.0 diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index 0e950fa1f..3f08eb363 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -70,7 +70,7 @@ void findRoot0(double *variables) variables[2] = u[2]; } -void initialiseVariables(double *variables) +void initialiseVariables(double *constants) { variables[0] = 1.0; variables[1] = 1.0; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index d09497bd0..95cddbeb4 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -29,6 +29,6 @@ extern const VariableInfo VARIABLE_INFO[]; double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *variables); +void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c index e722bff08..379ddae4e 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c @@ -67,7 +67,7 @@ void findRoot0(double *variables) variables[2] = u[1]; } -void initialiseVariables(double *variables, ExternalVariable externalVariable) +void initialiseVariables(double *constants, ExternalVariable externalVariable) { variables[1] = 1.0; variables[2] = 1.0; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h index e1fdbe098..df0655d6f 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *variables, ExternalVariable externalVariable); +void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py index 89a57c41c..d51f24510 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py @@ -56,7 +56,7 @@ def find_root_0(variables): variables[2] = u[1] -def initialise_variables(variables, external_variable): +def initialise_variables(constants, external_variable): variables[1] = 1.0 variables[2] = 1.0 variables[0] = external_variable(variables, 0) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 9125b7c1d..ad98c51d7 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -58,7 +58,7 @@ def find_root_0(variables): variables[2] = u[2] -def initialise_variables(variables): +def initialise_variables(constants): variables[0] = 1.0 variables[1] = 1.0 variables[2] = 1.0 diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index a5ec7515f..7cbf8256a 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -34,7 +34,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *variables, ExternalVariable externalVariable) +void initialiseVariables(double *constants, ExternalVariable externalVariable) { variables[0] = externalVariable(variables, 0); variables[1] = externalVariable(variables, 1); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index e1fdbe098..df0655d6f 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *variables, ExternalVariable externalVariable); +void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index 2dde0e032..bf285d55d 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -30,7 +30,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables, external_variable): +def initialise_variables(constants, external_variable): variables[0] = external_variable(variables, 0) variables[1] = external_variable(variables, 1) variables[2] = external_variable(variables, 2) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c index b4213f7a3..9be838cc4 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c @@ -104,7 +104,7 @@ void findRoot2(double *variables) variables[1] = u[0]; } -void initialiseVariables(double *variables, ExternalVariable externalVariable) +void initialiseVariables(double *constants, ExternalVariable externalVariable) { variables[1] = 1.0; variables[0] = externalVariable(variables, 0); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h index e1fdbe098..df0655d6f 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *variables, ExternalVariable externalVariable); +void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py index d18695e14..2001d6080 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py @@ -87,7 +87,7 @@ def find_root_2(variables): variables[1] = u[0] -def initialise_variables(variables, external_variable): +def initialise_variables(constants, external_variable): variables[1] = 1.0 variables[0] = external_variable(variables, 0) variables[2] = external_variable(variables, 2) diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index 002200921..fc3136279 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -69,7 +69,7 @@ void findRoot0(double *variables) variables[1] = u[1]; } -void initialiseVariables(double *variables) +void initialiseVariables(double *constants) { variables[1] = 1.0; variables[2] = 1.0; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index d09497bd0..95cddbeb4 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -29,6 +29,6 @@ extern const VariableInfo VARIABLE_INFO[]; double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *variables); +void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 5b34036e4..389dbfc4d 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -57,7 +57,7 @@ def find_root_0(variables): variables[1] = u[1] -def initialise_variables(variables): +def initialise_variables(constants): variables[1] = 1.0 variables[2] = 1.0 variables[4] = 3.0 diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index 7ee14bfeb..35fe86e31 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -69,7 +69,7 @@ void findRoot0(double *variables) variables[4] = u[1]; } -void initialiseVariables(double *variables) +void initialiseVariables(double *constants) { variables[1] = 3.0; variables[2] = 5.0; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index d09497bd0..95cddbeb4 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -29,6 +29,6 @@ extern const VariableInfo VARIABLE_INFO[]; double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *variables); +void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 640f553c3..ec5c0bbf2 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -57,7 +57,7 @@ def find_root_0(variables): variables[4] = u[1] -def initialise_variables(variables): +def initialise_variables(constants): variables[1] = 3.0 variables[2] = 5.0 variables[3] = 1.0 diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index 7991acc69..e02a8b142 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -33,7 +33,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *variables) +void initialiseVariables(double *constants) { variables[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index 0ca7442cf..230086c60 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -29,6 +29,6 @@ extern const VariableInfo VARIABLE_INFO[]; double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *variables); +void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index a7b0a114c..a273db38c 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -28,7 +28,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables): +def initialise_variables(constants): variables[0] = 1.0 diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index 02f1470c4..b69bd0e05 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -35,7 +35,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *variables) +void initialiseVariables(double *constants) { variables[1] = 0.01; variables[2] = 0.0011; diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 23c8e5b5b..3ceea7e7a 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -35,7 +35,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *variables, ExternalVariable externalVariable) +void initialiseVariables(double *constants, ExternalVariable externalVariable) { variables[1] = externalVariable(variables, 1); variables[2] = externalVariable(variables, 2); diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index be4c0a832..86e769ee4 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *variables, ExternalVariable externalVariable); +void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 741f7235d..3d69c78ed 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -31,7 +31,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables, external_variable): +def initialise_variables(constants, external_variable): variables[1] = external_variable(variables, 1) variables[2] = external_variable(variables, 2) diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index 2eeadc793..882e0d6ab 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -29,6 +29,6 @@ extern const VariableInfo VARIABLE_INFO[]; double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *variables); +void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index b6844d13f..48ad53c10 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -30,7 +30,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables): +def initialise_variables(constants): variables[1] = 0.01 variables[2] = 0.0011 diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 70dec9ba6..cf7fe6f05 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -52,7 +52,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index 5127bc9de..714fa4d81 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index ed00088c5..c45ea5a1c 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -42,7 +42,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): states[0] = 1.0 states[1] = 0.0 diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index 657ee35e4..4afceca0c 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -36,7 +36,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables): +def initialise_variables(constants): variables[1] = 1.1 variables[2] = 21262500.0 variables[3] = 150.0 diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index 67bf67f14..ba79edb18 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -50,7 +50,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 123.0; states[0] = variables[0]; diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index 353681ed9..3140db530 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index ee8ef1478..690365c51 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -40,7 +40,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 123.0 states[0] = variables[0] diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 9131b2ba1..790526d9c 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -34,7 +34,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *variables) +void initialiseVariables(double *constants) { variables[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index 7d11520a1..5499853e3 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -29,6 +29,6 @@ extern const VariableInfo VARIABLE_INFO[]; double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *variables); +void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index 2380d4c77..7a674f901 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -29,7 +29,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables): +def initialise_variables(constants): variables[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 48c0c0e0c..78c1c7252 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -51,7 +51,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index 353681ed9..3140db530 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 99005d82b..ed0b68c4d 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -41,7 +41,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 1e434a624..633c056f5 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -51,7 +51,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index 353681ed9..3140db530 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index 67c70992c..f29570cd3 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -41,7 +41,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index d84efc4cd..31ae730d0 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -50,7 +50,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { states[0] = 123.0; states[1] = 0.001*789.0; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index aa242b8af..75763d81b 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index b60faccff..8adebd968 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -40,7 +40,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): states[0] = 123.0 states[1] = 0.001*789.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index fdd80b095..c8b1b99cd 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -52,7 +52,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 123.0; variables[1] = 789.0; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 28a98085d..267e6b8b3 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index f04a5b936..b3b95e4e8 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -42,7 +42,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 123.0 variables[1] = 789.0 states[0] = variables[0] diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index 1f652c788..33e574ae5 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -50,7 +50,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { states[0] = 3.0; states[1] = 5.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index 614cdc5ec..2279ebcc1 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index 6dfca0a42..7e51296b6 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -40,7 +40,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): states[0] = 3.0 states[1] = 5.0 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index 54994da7d..aac78a605 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -51,7 +51,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { states[0] = 3.0; states[1] = 7.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 0ae986111..176d86319 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index 4bc1c304c..c14ff09f0 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -41,7 +41,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): states[0] = 3.0 states[1] = 7.0 states[2] = 11.0 diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 3a1022aa7..21cfacf83 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -118,7 +118,7 @@ void findRoot1(double voi, double *states, double *rates, double *variables) variables[6] = u[0]; } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 0.0; variables[1] = 1.0; diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 4b380a3b4..e11fde1f1 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index fd86ef428..931f4c83c 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -95,7 +95,7 @@ def find_root_1(voi, states, rates, variables): variables[6] = u[0] -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 0.0 variables[1] = 1.0 variables[3] = 1.0 diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 6aa94c3bf..76910519b 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -51,7 +51,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { states[0] = 0.0; } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 8387ea6e2..7485defac 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index cee82a74b..c9ee52382 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -41,7 +41,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): states[0] = 0.0 diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 29744dac7..8ddf41a6e 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -298,7 +298,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 0.0; variables[1] = 0.0; diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 91f60ad4e..64a364e17 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index d21a0dd17..a5cc60a71 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -308,7 +308,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 0.0 variables[1] = 0.0 variables[4] = 140.0 diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index c473d0e8c..81355e42c 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -248,7 +248,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[1] = 0.0; variables[2] = 1.0; diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 9c13c3f34..09c8efc8c 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index c2cb44155..86fa99ce9 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -246,7 +246,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[1] = 0.0 variables[2] = 1.0 variables[3] = 1.0309347 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index b148c0bbd..7e75a9982 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -70,7 +70,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { variables[4] = 1.0; variables[5] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index e1fb1b494..b6719b8af 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -38,7 +38,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 72dbf27cf..5c9aa53b7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -73,7 +73,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(voi, states, rates, variables, external_variable): +def initialise_variables(voi, states, rates, constants, external_variable): variables[4] = 1.0 variables[5] = 0.0 variables[7] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index a30ed76d2..b423facc6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -70,7 +70,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[4] = 1.0; variables[5] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 8ef6fb89f..6c97d8386 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -70,7 +70,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { variables[4] = 1.0; variables[5] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index e1fb1b494..b6719b8af 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -38,7 +38,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 4e2c615a6..46fd13330 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -73,7 +73,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(voi, states, rates, variables, external_variable): +def initialise_variables(voi, states, rates, constants, external_variable): variables[4] = 1.0 variables[5] = 0.0 variables[7] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index f28ef90f4..92007545f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -70,7 +70,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { variables[5] = 0.0; variables[7] = 0.3; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index e1fb1b494..b6719b8af 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -38,7 +38,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index efb48bb7b..c171a09b7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -73,7 +73,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(voi, states, rates, variables, external_variable): +def initialise_variables(voi, states, rates, constants, external_variable): variables[5] = 0.0 variables[7] = 0.3 variables[9] = 120.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index f84acb2cd..38f83ab65 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -488,7 +488,7 @@ void findRoot16(double voi, double *states, double *rates, double *variables) rates[3] = u[0]; } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 0.0; variables[1] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index 18f278fee..44cab4bac 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index b377d909c..a31fb836b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -432,7 +432,7 @@ def find_root_16(voi, states, rates, variables): rates[3] = u[0] -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 0.0 variables[1] = 0.0 variables[2] = 0.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 3bff29098..89e69a335 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -70,7 +70,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { variables[4] = 1.0; variables[5] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index e1fb1b494..b6719b8af 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -38,7 +38,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index b3482e4bc..7970569a1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -73,7 +73,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(voi, states, rates, variables, external_variable): +def initialise_variables(voi, states, rates, constants, external_variable): variables[4] = 1.0 variables[5] = 0.0 variables[7] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 8820f3fac..0539e453f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -70,7 +70,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { variables[4] = 1.0; variables[7] = 0.3; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index e1fb1b494..b6719b8af 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -38,7 +38,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 1906e26f0..18c3c3226 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -73,7 +73,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(voi, states, rates, variables, external_variable): +def initialise_variables(voi, states, rates, constants, external_variable): variables[4] = 1.0 variables[7] = 0.3 variables[9] = 120.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index ec4314811..eaaa5a341 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -70,7 +70,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { variables[5] = 0.0; variables[7] = 0.3; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index e1fb1b494..b6719b8af 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -38,7 +38,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index eb9c6b8d0..aacb68320 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -73,7 +73,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(voi, states, rates, variables, external_variable): +def initialise_variables(voi, states, rates, constants, external_variable): variables[5] = 0.0 variables[7] = 0.3 variables[15] = 36.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 8157734aa..612c48a65 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -70,7 +70,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { variables[5] = 1.0; variables[6] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index e1fb1b494..b6719b8af 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -38,7 +38,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 114074129..f49e72de7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -73,7 +73,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(voi, states, rates, variables, external_variable): +def initialise_variables(voi, states, rates, constants, external_variable): variables[5] = 1.0 variables[6] = 0.0 variables[8] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index d82480785..77a77fa86 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -70,7 +70,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { variables[5] = 1.0; variables[6] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index e1fb1b494..b6719b8af 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -38,7 +38,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index cc74a6a43..a1d9455d8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -73,7 +73,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(voi, states, rates, variables, external_variable): +def initialise_variables(voi, states, rates, constants, external_variable): variables[5] = 1.0 variables[6] = 0.0 variables[8] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index 18f278fee..44cab4bac 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index cdbfc277a..2b363c20b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -72,7 +72,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[4] = 1.0 variables[5] = 0.0 variables[7] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 4689c74e6..d3bc35182 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -70,7 +70,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { variables[4] = 1.0; variables[5] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index e1fb1b494..b6719b8af 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -38,7 +38,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 771fbc441..877a3c3c1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -73,7 +73,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(voi, states, rates, variables, external_variable): +def initialise_variables(voi, states, rates, constants, external_variable): variables[4] = 1.0 variables[5] = 0.0 variables[7] = 0.3 diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index af60ee489..bed1c02e3 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -69,7 +69,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[3] = 12.0; variables[4] = 0.075; diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index 6988d2d31..41269862e 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 52a828364..433f53e11 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -59,7 +59,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[3] = 12.0 variables[4] = 0.075 variables[5] = -60.0 diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 529cf1804..347ca221a 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -50,7 +50,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index 614cdc5ec..2279ebcc1 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index ec7afe8e0..23fe7ca71 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -40,7 +40,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 5d8747a40..70697999b 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -50,7 +50,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index d1084de7a..be002fd71 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index e15d14089..7cf75939a 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -40,7 +40,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index 59be2f295..242e528d0 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -50,7 +50,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index 614cdc5ec..2279ebcc1 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 5d5b92520..8c2d64ebe 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -40,7 +40,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index a5074645d..c2cfa30a0 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -50,7 +50,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index d1084de7a..be002fd71 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 801a2997d..40fec5173 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -40,7 +40,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index c026c7404..8c25b8b32 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -49,7 +49,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index 614cdc5ec..2279ebcc1 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index 20c1034b0..fb01dd88d 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -39,7 +39,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): states[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 07897e662..48f4705fa 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -49,7 +49,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index d1084de7a..be002fd71 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index 096a989a7..4655c2f75 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -39,7 +39,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): states[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index d0ae43433..94db2285b 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -51,7 +51,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 1.0; states[0] = -2.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index b5625ea2d..e3079caa5 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 37a213fb2..07ee839b4 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -41,7 +41,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 1.0 states[0] = -2.0 states[1] = 0.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 627806b47..addbc4250 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -51,7 +51,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 1.0; states[0] = -2.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index a559621fe..f75d27774 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index a020f5101..320add744 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -41,7 +41,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 1.0 states[0] = -2.0 states[1] = 0.0 diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 40cc955ab..bd59a1786 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -51,7 +51,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index 2b904e6bc..c1830c26f 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 06b202ef8..0c442c182 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -41,7 +41,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 1.0 states[0] = 1.0 states[1] = 1.0 diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index 0f39593a5..8d5a4124a 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -50,7 +50,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { states[0] = 1.0; states[1] = 1.0; diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index 614cdc5ec..2279ebcc1 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index eb04fc9df..70d8d2ad0 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -40,7 +40,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): states[0] = 1.0 states[1] = 1.0 diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 36df485fd..b083983e4 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -89,7 +89,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) variables[2] = u[0]; } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 0.04; variables[1] = 1.0e4; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index e5229113e..fe620e70f 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 9e6f0c27e..43ed6059b 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -69,7 +69,7 @@ def find_root_0(voi, states, rates, variables): variables[2] = u[0] -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 0.04 variables[1] = 1.0e4 variables[2] = 0.0 diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 56108226b..40304d9a6 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -55,7 +55,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 0.04; variables[1] = 1.0e4; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index e5229113e..fe620e70f 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 0f7a9c039..d80b59dfc 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -45,7 +45,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 0.04 variables[1] = 1.0e4 variables[2] = 3.0e7 diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 5dbedca63..aa2e6b1ce 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -59,7 +59,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[1] = 0.0; variables[3] = 0.75; diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index 442d67f1c..613e4f9aa 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 0feacef13..191913e4a 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -53,7 +53,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[1] = 0.0 variables[3] = 0.75 variables[4] = 2.0/3.14159265358979 diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index ccabbc6bb..f8e4ac81c 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -41,7 +41,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *variables, ExternalVariable externalVariable) +void initialiseVariables(double *constants, ExternalVariable externalVariable) { variables[1] = 1.1; variables[2] = 21262500.0; diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 0673bd2f6..d8442ae9e 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *variables, ExternalVariable externalVariable); +void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeVariables(double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 90ace85bd..7c13d97e3 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -37,7 +37,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(variables, external_variable): +def initialise_variables(constants, external_variable): variables[1] = 1.1 variables[2] = 21262500.0 variables[3] = 150.0 diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 4f6983da4..469b04c72 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -50,7 +50,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *variables) +void initialiseVariables(double *states, double *rates, double *constants) { variables[0] = 7.0; states[0] = variables[0]; diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index 4db60c5e2..a92fc36f8 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -35,7 +35,7 @@ double * createStatesArray(); double * createVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *variables); +void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *variables); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 929ca69ec..ff57a7683 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -40,7 +40,7 @@ def create_variables_array(): return [nan]*VARIABLE_COUNT -def initialise_variables(states, rates, variables): +def initialise_variables(states, rates, constants): variables[0] = 7.0 states[0] = variables[0] From 56a86583d4ed7f759f514aa75e1006ba42faf1f2 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 7 Aug 2024 16:20:27 +0200 Subject: [PATCH 04/74] Generator: use different arrays for constants, computed constants, and algebraic variables for computeRates(). --- src/generatorprofile.cpp | 12 ++++++------ src/generatorprofilesha1values.h | 4 ++-- tests/bindings/python/test_generator_profile.py | 8 ++++---- tests/generator/generatorprofile.cpp | 8 ++++---- tests/resources/coverage/generator/model.c | 2 +- tests/resources/coverage/generator/model.h | 2 +- .../coverage/generator/model.implementation.out | 2 +- .../resources/coverage/generator/model.interface.out | 2 +- .../coverage/generator/model.modified.profile.c | 2 +- .../coverage/generator/model.modified.profile.h | 2 +- .../coverage/generator/model.modified.profile.py | 2 +- tests/resources/coverage/generator/model.out | 2 +- tests/resources/coverage/generator/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs/model.h | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.h | 2 +- .../algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../cellml_mappings_and_encapsulations/model.c | 2 +- .../cellml_mappings_and_encapsulations/model.h | 2 +- .../cellml_mappings_and_encapsulations/model.py | 2 +- .../cellml_state_initialised_using_variable/model.c | 2 +- .../cellml_state_initialised_using_variable/model.h | 2 +- .../cellml_state_initialised_using_variable/model.py | 2 +- .../generator/cellml_unit_scaling_rate/model.c | 2 +- .../generator/cellml_unit_scaling_rate/model.h | 2 +- .../generator/cellml_unit_scaling_rate/model.py | 2 +- .../generator/cellml_unit_scaling_state/model.c | 2 +- .../generator/cellml_unit_scaling_state/model.h | 2 +- .../generator/cellml_unit_scaling_state/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.c | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.h | 2 +- .../cellml_unit_scaling_voi_direct/model.py | 2 +- .../cellml_unit_scaling_voi_indirect/model.c | 2 +- .../cellml_unit_scaling_voi_indirect/model.h | 2 +- .../cellml_unit_scaling_voi_indirect/model.py | 2 +- .../resources/generator/dae_cellml_1_1_model/model.c | 2 +- .../resources/generator/dae_cellml_1_1_model/model.h | 2 +- .../generator/dae_cellml_1_1_model/model.py | 2 +- tests/resources/generator/dependent_eqns/model.c | 2 +- tests/resources/generator/dependent_eqns/model.h | 2 +- tests/resources/generator/dependent_eqns/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.algebraic.c | 2 +- .../model.algebraic.h | 2 +- .../model.algebraic.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.c | 2 +- .../model.computed.constant.c | 2 +- .../model.computed.constant.h | 2 +- .../model.computed.constant.py | 2 +- .../model.constant.c | 2 +- .../model.constant.h | 2 +- .../model.constant.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.h | 2 +- .../model.dae.py | 2 +- .../model.dependent.algebraic.c | 2 +- .../model.dependent.algebraic.h | 2 +- .../model.dependent.algebraic.py | 2 +- .../model.dependent.computed.constant.c | 2 +- .../model.dependent.computed.constant.h | 2 +- .../model.dependent.computed.constant.py | 2 +- .../model.dependent.constant.c | 2 +- .../model.dependent.constant.h | 2 +- .../model.dependent.constant.py | 2 +- .../model.dependent.state.c | 2 +- .../model.dependent.state.h | 2 +- .../model.dependent.state.py | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.py | 2 +- .../model.state.c | 2 +- .../model.state.h | 2 +- .../model.state.py | 2 +- tests/resources/generator/noble_model_1962/model.c | 2 +- tests/resources/generator/noble_model_1962/model.h | 2 +- tests/resources/generator/noble_model_1962/model.py | 2 +- .../generator/ode_computed_var_on_rhs/model.c | 2 +- .../generator/ode_computed_var_on_rhs/model.h | 2 +- .../generator/ode_computed_var_on_rhs/model.py | 2 +- .../ode_computed_var_on_rhs_one_component/model.c | 2 +- .../ode_computed_var_on_rhs_one_component/model.h | 2 +- .../ode_computed_var_on_rhs_one_component/model.py | 2 +- .../resources/generator/ode_const_var_on_rhs/model.c | 2 +- .../resources/generator/ode_const_var_on_rhs/model.h | 2 +- .../generator/ode_const_var_on_rhs/model.py | 2 +- .../ode_const_var_on_rhs_one_component/model.c | 2 +- .../ode_const_var_on_rhs_one_component/model.h | 2 +- .../ode_const_var_on_rhs_one_component/model.py | 2 +- .../resources/generator/ode_constant_on_rhs/model.c | 2 +- .../resources/generator/ode_constant_on_rhs/model.h | 2 +- .../resources/generator/ode_constant_on_rhs/model.py | 2 +- .../ode_constant_on_rhs_one_component/model.c | 2 +- .../ode_constant_on_rhs_one_component/model.h | 2 +- .../ode_constant_on_rhs_one_component/model.py | 2 +- .../generator/ode_multiple_dependent_odes/model.c | 2 +- .../generator/ode_multiple_dependent_odes/model.h | 2 +- .../generator/ode_multiple_dependent_odes/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../ode_multiple_odes_with_same_name/model.c | 2 +- .../ode_multiple_odes_with_same_name/model.h | 2 +- .../ode_multiple_odes_with_same_name/model.py | 2 +- .../generator/ode_unknown_var_on_rhs/model.c | 2 +- .../generator/ode_unknown_var_on_rhs/model.h | 2 +- .../generator/ode_unknown_var_on_rhs/model.py | 2 +- .../generator/robertson_model_1966/model.dae.c | 2 +- .../generator/robertson_model_1966/model.dae.h | 2 +- .../generator/robertson_model_1966/model.dae.py | 2 +- .../generator/robertson_model_1966/model.ode.c | 2 +- .../generator/robertson_model_1966/model.ode.h | 2 +- .../generator/robertson_model_1966/model.ode.py | 2 +- tests/resources/generator/sine_model_imports/model.c | 2 +- tests/resources/generator/sine_model_imports/model.h | 2 +- .../resources/generator/sine_model_imports/model.py | 2 +- .../variable_initialised_using_a_constant/model.c | 2 +- .../variable_initialised_using_a_constant/model.h | 2 +- .../variable_initialised_using_a_constant/model.py | 2 +- 139 files changed, 151 insertions(+), 151 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index f69e51b92..97861c3c3 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -695,13 +695,13 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "}\n"; - mInterfaceComputeRatesMethodWoevString = "void computeRates(double voi, double *states, double *rates, double *variables);\n"; - mImplementationComputeRatesMethodWoevString = "void computeRates(double voi, double *states, double *rates, double *variables)\n{\n" + mInterfaceComputeRatesMethodWoevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n"; + mImplementationComputeRatesMethodWoevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n" "[CODE]" "}\n"; - mInterfaceComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable);\n"; - mImplementationComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable)\n{\n" + mInterfaceComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n"; + mImplementationComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n{\n" "[CODE]" "}\n"; @@ -1097,12 +1097,12 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceComputeRatesMethodWoevString = ""; mImplementationComputeRatesMethodWoevString = "\n" - "def compute_rates(voi, states, rates, variables):\n" + "def compute_rates(voi, states, rates, constants, computedConstants, algebraic):\n" "[CODE]"; mInterfaceComputeRatesMethodWevString = ""; mImplementationComputeRatesMethodWevString = "\n" - "def compute_rates(voi, states, rates, variables, external_variable):\n" + "def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable):\n" "[CODE]"; mInterfaceComputeVariablesMethodFamWoevString = ""; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 8661315d2..9d8261e55 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "12b8069d68c8c5ebe36b14a90c0bfb880d61b73d"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "ed70973a0cf394f386857d43bb4497b9b7f99e03"; +static const char C_GENERATOR_PROFILE_SHA1[] = "47a9b5b8e33ce2fa29c0385e0debe1d295a7e313"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "f171d1553ad485ad286b4a1152bc7d89631750a6"; } // namespace libcellml diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 0d48a9a24..200b1fc25 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -772,13 +772,13 @@ def test_implementation_compute_rates_method_string(self): g = GeneratorProfile() self.assertEqual( - 'void computeRates(double voi, double *states, double *rates, double *variables)\n{\n[CODE]}\n', + 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', g.implementationComputeRatesMethodString(False)) g.setImplementationComputeRatesMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeRatesMethodString(False)) self.assertEqual( - 'void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable)\n{\n[CODE]}\n', + 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationComputeRatesMethodString(True)) g.setImplementationComputeRatesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeRatesMethodString(True)) @@ -996,13 +996,13 @@ def test_interface_compute_rates_method_string(self): g = GeneratorProfile() self.assertEqual( - 'void computeRates(double voi, double *states, double *rates, double *variables);\n', + 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n', g.interfaceComputeRatesMethodString(False)) g.setInterfaceComputeRatesMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeRatesMethodString(False)) self.assertEqual( - 'void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable);\n', + 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n', g.interfaceComputeRatesMethodString(True)) g.setInterfaceComputeRatesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeRatesMethodString(True)) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 401b6dddd..739baf735 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -499,17 +499,17 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationComputeComputedConstantsMethodString()); - EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *variables);\n", + EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n", generatorProfile->interfaceComputeRatesMethodString(false)); - EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *variables)\n" + EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationComputeRatesMethodString(false)); - EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable);\n", + EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n", generatorProfile->interfaceComputeRatesMethodString(true)); - EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable)\n" + EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index f42a71569..9de875153 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -595,7 +595,7 @@ void computeComputedConstants(double *computedConstants) variables[204] = -(variables[1] && variables[2])+-((variables[6] > variables[18])?variables[2]:NAN); } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.0; } diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 33bedee9e..7730315fc 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 64b0e5915..9ffecca32 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -364,7 +364,7 @@ void computeComputedConstants(double *computedConstants) variables[204] = -and(variables[1], variables[2])+-((gt(variables[6], variables[18]))?variables[2]:NAN); } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.0; } diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index 4efd4f2df..efdce8c67 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -10,5 +10,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 105e8415b..c35f5846f 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -595,7 +595,7 @@ void computeComputedConstants(double *computedConstants) variables[204] = -(variables[1] && variables[2])+-((variables[6] > variables[18])?variables[2]:NAN); } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.0; } diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 15b44e7e6..64ce0aa87 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 178219f7e..f2c561dfd 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -594,7 +594,7 @@ def compute_computed_constants(computed_constants): variables[204] = -and_func(variables[1], variables[2])+-(variables[2] if gt_func(variables[6], variables[18]) else nan) -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index a8b63dc14..18d0685f7 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -334,7 +334,7 @@ void computeComputedConstants(double *computedConstants) variables[204] = -(variables[1] && variables[2])+-piecewise(variables[6] > variables[18], variables[2], NAN); } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.0; } diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index ef2576587..14f9649a8 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -594,7 +594,7 @@ def compute_computed_constants(computed_constants): variables[204] = -and_func(variables[1], variables[2])+-(variables[2] if gt_func(variables[6], variables[18]) else nan) -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 72996b13e..9b3bafb89 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -61,7 +61,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = variables[0]; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index b7c0c64e3..d05526b0f 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index a7ae59d7c..fab4c53eb 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -50,7 +50,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 600e33650..1c98887b5 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -61,7 +61,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = variables[0]; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index be002fd71..7f86bfafd 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 546587aa9..5a1db9e80 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -50,7 +50,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 55b34a516..4539a94e6 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -61,7 +61,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = variables[0]; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index e1313e395..687e4f315 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 6ea7c7cd7..59f13819a 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -50,7 +50,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 03905f281..3a124f662 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -61,7 +61,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = variables[0]; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index 90ebf612d..b30eab519 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 866f33265..1ed616c4f 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -50,7 +50,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index cf7fe6f05..c4d18d612 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -62,7 +62,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[1] = -states[0]*1.0; rates[0] = states[1]*1.0; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index 714fa4d81..edaae29a0 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index c45ea5a1c..dc65de94a 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -51,7 +51,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = -states[0]*1.0 rates[0] = states[1]*1.0 diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index ba79edb18..3475b85d5 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.23; } diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index 3140db530..3c03deb82 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 690365c51..d0b35c939 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.23 diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 78c1c7252..9af4c26b6 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.23; } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index 3140db530..3c03deb82 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index ed0b68c4d..81b99cccc 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.23 diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 633c056f5..d89ec5205 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.23; } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index 3140db530..3c03deb82 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index f29570cd3..8ea99efc5 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.23 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index 31ae730d0..a369dea89 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.23; rates[1] = 7.89; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index 75763d81b..6a04a2fbc 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index 8adebd968..1217a8d8a 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.23 rates[1] = 7.89 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index c8b1b99cd..3300a1507 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -64,7 +64,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.23; rates[1] = 7.89; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 267e6b8b3..4c3949f2a 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index b3b95e4e8..9db1db120 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -53,7 +53,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.23 rates[1] = 7.89 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index 33e574ae5..01ebcf426 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = voi/1.0; rates[1] = 0.001*voi/1.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index 2279ebcc1..0bccaf5c8 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index 7e51296b6..98608474d 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = voi/1.0 rates[1] = 0.001*voi/1.0 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index aac78a605..3001a87e8 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -62,7 +62,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 5.0; rates[1] = 1000.0*9.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 176d86319..e39db828a 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index c14ff09f0..3571fc789 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -51,7 +51,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 5.0 rates[1] = 1000.0*9.0 rates[2] = 0.001*13.0 diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 21cfacf83..30a8c5729 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -135,7 +135,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[2] = states[1]+variables[3]; findRoot0(voi, states, rates, variables); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index e11fde1f1..23a61c61e 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 931f4c83c..f0c69dd15 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -111,7 +111,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): variables[2] = states[1]+variables[3] find_root_0(voi, states, rates, variables) rates[0] = variables[0] diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 76910519b..670fcf620 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.0; } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 7485defac..529dbd03f 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index c9ee52382..a48ff4587 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 8ddf41a6e..488858b66 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -455,7 +455,7 @@ void computeComputedConstants(double *computedConstants) variables[213] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*variables[0], 1.6951))+0.025641; } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[5] = states[1]; variables[142] = variables[3]*log((variables[4]+0.12*variables[7])/(variables[5]+0.12*variables[8])); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 64a364e17..c0a9edbff 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index a5cc60a71..9306dbef6 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -463,7 +463,7 @@ def compute_computed_constants(computed_constants): variables[213] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*variables[0], 1.6951))+0.025641 -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): variables[5] = states[1] variables[142] = variables[3]*log((variables[4]+0.12*variables[7])/(variables[5]+0.12*variables[8])) variables[121] = variables[123] if and_func(gt_func(voi, variables[124]), lt_func(voi, variables[124]+variables[125])) else variables[126] diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 81355e42c..67fc7303c 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -404,7 +404,7 @@ void computeComputedConstants(double *computedConstants) variables[176] = (variables[2] == 0.0)?variables[177]+variables[0]*(variables[178]-variables[177]):(variables[2] == 1.0)?variables[181]+variables[0]*(variables[182]-variables[181]):variables[179]+variables[0]*(variables[180]-variables[179]); } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[9] = variables[62]*pow(variables[56]/(variables[71]+variables[56]), 3.0)*pow(variables[69]/(variables[70]+variables[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); variables[10] = (variables[2] == 0.0)?variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.0374*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))):variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.03743*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 09c8efc8c..c574f5af0 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 86fa99ce9..73447539d 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -400,7 +400,7 @@ def compute_computed_constants(computed_constants): variables[176] = variables[177]+variables[0]*(variables[178]-variables[177]) if eq_func(variables[2], 0.0) else variables[181]+variables[0]*(variables[182]-variables[181]) if eq_func(variables[2], 1.0) else variables[179]+variables[0]*(variables[180]-variables[179]) -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): variables[9] = variables[62]*pow(variables[56]/(variables[71]+variables[56]), 3.0)*pow(variables[69]/(variables[70]+variables[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) variables[10] = variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.0374*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))) if eq_func(variables[2], 0.0) else variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.03743*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))) variables[14] = variables[176]*states[14]*(states[0]-variables[40]) if neq_func(variables[2], 2.0) else variables[176]*states[14]*(states[0]+102.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 7e75a9982..76221f43e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -91,7 +91,7 @@ void computeComputedConstants(double *computedConstants) variables[14] = variables[5]+12.0; } -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = externalVariable(voi, states, rates, variables, 0); variables[1] = variables[7]*(states[0]-variables[6]); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index b6719b8af..b85f55026 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -40,5 +40,5 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 5c9aa53b7..ec1244d2f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -92,7 +92,7 @@ def compute_computed_constants(computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, variables, external_variable): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[0] = external_variable(voi, states, rates, variables, 0) variables[1] = variables[7]*(states[0]-variables[6]) variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index b423facc6..bfc76d2c8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -90,7 +90,7 @@ void computeComputedConstants(double *computedConstants) variables[14] = variables[5]+12.0; } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; variables[1] = variables[7]*(states[0]-variables[6]); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 6c97d8386..22550c76d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -90,7 +90,7 @@ void computeComputedConstants(double *computedConstants) variables[14] = variables[5]+12.0; } -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; variables[6] = externalVariable(voi, states, rates, variables, 6); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index b6719b8af..b85f55026 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -40,5 +40,5 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 46fd13330..31eb6b9db 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -91,7 +91,7 @@ def compute_computed_constants(computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, variables, external_variable): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[6] = external_variable(voi, states, rates, variables, 6) variables[1] = variables[7]*(states[0]-variables[6]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 92007545f..2ec875f7c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -90,7 +90,7 @@ void computeComputedConstants(double *computedConstants) variables[14] = variables[5]+12.0; } -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; variables[4] = externalVariable(voi, states, rates, variables, 4); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index b6719b8af..b85f55026 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -40,5 +40,5 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index c171a09b7..6db074dda 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -91,7 +91,7 @@ def compute_computed_constants(computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, variables, external_variable): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[4] = external_variable(voi, states, rates, variables, 4) variables[1] = variables[7]*(states[0]-variables[6]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 38f83ab65..8b8dee0b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -522,7 +522,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, variables); findRoot2(voi, states, rates, variables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index 44cab4bac..ef02301bd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index a31fb836b..0f940110a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -465,7 +465,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): find_root_0(voi, states, rates, variables) find_root_2(voi, states, rates, variables) find_root_3(voi, states, rates, variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 89e69a335..b50aa4b59 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -92,7 +92,7 @@ void computeComputedConstants(double *computedConstants) variables[14] = variables[5]+12.0; } -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[17] = externalVariable(voi, states, rates, variables, 17); variables[0] = externalVariable(voi, states, rates, variables, 0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index b6719b8af..b85f55026 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -40,5 +40,5 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 7970569a1..53d4e89f8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -93,7 +93,7 @@ def compute_computed_constants(computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, variables, external_variable): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[17] = external_variable(voi, states, rates, variables, 17) variables[0] = external_variable(voi, states, rates, variables, 0) variables[1] = variables[7]*(states[0]-variables[6]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 0539e453f..89553d7e3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -88,7 +88,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; variables[14] = externalVariable(voi, states, rates, variables, 14); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index b6719b8af..b85f55026 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -40,5 +40,5 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 18c3c3226..6b5f48f3a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -90,7 +90,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables, external_variable): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[14] = external_variable(voi, states, rates, variables, 14) variables[5] = external_variable(voi, states, rates, variables, 5) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index eaaa5a341..9577016c1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -90,7 +90,7 @@ void computeComputedConstants(double *computedConstants) variables[14] = variables[5]+12.0; } -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; variables[9] = externalVariable(voi, states, rates, variables, 9); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index b6719b8af..b85f55026 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -40,5 +40,5 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index aacb68320..316463d2b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -91,7 +91,7 @@ def compute_computed_constants(computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, variables, external_variable): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[9] = external_variable(voi, states, rates, variables, 9) variables[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 612c48a65..84f5c32d2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -90,7 +90,7 @@ void computeComputedConstants(double *computedConstants) variables[16] = variables[6]+12.0; } -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[1] = externalVariable(voi, states, rates, variables, 1); variables[14] = 0.07*exp(variables[1]/20.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index b6719b8af..b85f55026 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -40,5 +40,5 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index f49e72de7..0b8179640 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -91,7 +91,7 @@ def compute_computed_constants(computed_constants): variables[16] = variables[6]+12.0 -def compute_rates(voi, states, rates, variables, external_variable): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[1] = external_variable(voi, states, rates, variables, 1) variables[14] = 0.07*exp(variables[1]/20.0) variables[15] = 1.0/(exp((variables[1]+30.0)/10.0)+1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 77a77fa86..e5a954f65 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -92,7 +92,7 @@ void computeComputedConstants(double *computedConstants) variables[15] = variables[6]+12.0; } -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[1] = externalVariable(voi, states, rates, variables, 1); variables[11] = 0.1*(variables[1]+25.0)/(exp((variables[1]+25.0)/10.0)-1.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index b6719b8af..b85f55026 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -40,5 +40,5 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index a1d9455d8..80610b753 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -93,7 +93,7 @@ def compute_computed_constants(computed_constants): variables[15] = variables[6]+12.0 -def compute_rates(voi, states, rates, variables, external_variable): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[1] = external_variable(voi, states, rates, variables, 1) variables[11] = 0.1*(variables[1]+25.0)/(exp((variables[1]+25.0)/10.0)-1.0) variables[12] = 4.0*exp(variables[1]/18.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index 44cab4bac..ef02301bd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 2b363c20b..ef8e528bf 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -90,7 +90,7 @@ def compute_computed_constants(computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[1] = variables[7]*(states[0]-variables[6]) variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index d3bc35182..27a4df313 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -90,7 +90,7 @@ void computeComputedConstants(double *computedConstants) variables[15] = variables[5]+12.0; } -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; variables[1] = variables[7]*(states[0]-variables[6]); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index b6719b8af..b85f55026 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -40,5 +40,5 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 877a3c3c1..fbbf62426 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -91,7 +91,7 @@ def compute_computed_constants(computed_constants): variables[15] = variables[5]+12.0 -def compute_rates(voi, states, rates, variables, external_variable): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[1] = variables[7]*(states[0]-variables[6]) variables[2] = variables[16]*pow(states[2], 4.0)*(states[0]-variables[15]) diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index bed1c02e3..2811d042f 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -86,7 +86,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[6] = pow(states[1], 3.0)*states[2]*variables[7]; variables[0] = (variables[6]+0.14)*(states[0]-variables[8]); diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index 41269862e..d6958fd5d 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 433f53e11..36858282f 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -75,7 +75,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): variables[6] = pow(states[1], 3.0)*states[2]*variables[7] variables[0] = (variables[6]+0.14)*(states[0]-variables[8]) variables[1] = variables[4]*(states[0]-variables[5]) diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 347ca221a..f6c4d954c 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = variables[0]; } diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index 2279ebcc1..0bccaf5c8 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 23fe7ca71..b3ac9c62f 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 70697999b..7f30100d5 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = variables[0]; } diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index be002fd71..7f86bfafd 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 7cf75939a..2dc19f393 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index 242e528d0..d630e604a 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = variables[0]; } diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index 2279ebcc1..0bccaf5c8 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 8c2d64ebe..ae0d7b060 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index c2cfa30a0..ddb0e28f9 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = variables[0]; } diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index be002fd71..7f86bfafd 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 40fec5173..ad34a0c19 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index 8c25b8b32..cc6439e9b 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -58,7 +58,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index 2279ebcc1..0bccaf5c8 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index fb01dd88d..58f3ce266 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -47,7 +47,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 48f4705fa..3cfebdce4 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -58,7 +58,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index be002fd71..7f86bfafd 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index 4655c2f75..0a9a86dba 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -47,7 +47,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 94db2285b..eb5bd6f89 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -62,7 +62,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = states[1]*1.0; rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index e3079caa5..72fe9729b 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 07ee839b4..9b6c3efa3 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -51,7 +51,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = states[1]*1.0 rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index addbc4250..aab636ab1 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -62,7 +62,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = states[1]*1.0; rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index f75d27774..2751faf2a 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 320add744..566c040ff 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -51,7 +51,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = states[1]*1.0 rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index bd59a1786..a372b5ab9 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -62,7 +62,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.0; rates[1] = variables[0]; diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index c1830c26f..d0b018b6f 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 0c442c182..c57a7c020 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -51,7 +51,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 rates[1] = variables[0] diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index 8d5a4124a..dc292a96c 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.0; rates[1] = states[0]; diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index 2279ebcc1..0bccaf5c8 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 70d8d2ad0..24271e0b3 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 rates[1] = states[0] diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index b083983e4..ff9bd2d42 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -103,7 +103,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, variables); rates[0] = -variables[0]*states[0]+variables[1]*states[1]*variables[2]; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index fe620e70f..4b40d5fc5 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 43ed6059b..d325fee60 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -82,7 +82,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): find_root_0(voi, states, rates, variables) rates[0] = -variables[0]*states[0]+variables[1]*states[1]*variables[2] rates[1] = variables[0]*states[0]-variables[3]*pow(states[1], 2.0)-variables[1]*states[1]*variables[2] diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 40304d9a6..cdea39537 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -69,7 +69,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = -variables[0]*states[0]+variables[1]*states[2]*states[1]; rates[2] = variables[0]*states[0]-variables[2]*pow(states[2], 2.0)-variables[1]*states[2]*states[1]; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index fe620e70f..4b40d5fc5 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index d80b59dfc..653a16bd6 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -58,7 +58,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = -variables[0]*states[0]+variables[1]*states[2]*states[1] rates[2] = variables[0]*states[0]-variables[2]*pow(states[2], 2.0)-variables[1]*states[2]*states[1] rates[1] = variables[2]*pow(states[2], 2.0) diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index aa2e6b1ce..cc9ad3939 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -75,7 +75,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = cos(voi); } diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index 613e4f9aa..175f6e2a0 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 191913e4a..75e2a697f 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -68,7 +68,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = cos(voi) diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 469b04c72..0d7a8cae4 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -60,7 +60,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *variables) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 3.0; } diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index a92fc36f8..8e703e9d2 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -37,5 +37,5 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *variables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *variables); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index ff57a7683..bbaccf6f6 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -49,7 +49,7 @@ def compute_computed_constants(computed_constants): pass -def compute_rates(voi, states, rates, variables): +def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 3.0 From 94515cc9e0db6db029dbdc2625aef51d449e127e Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 7 Aug 2024 16:41:40 +0200 Subject: [PATCH 05/74] Generator: use different arrays for constants, computed constants, and algebraic variables for computeVariables(). --- src/generatorprofile.cpp | 24 +++++++++---------- src/generatorprofilesha1values.h | 4 ++-- .../bindings/python/test_generator_profile.py | 16 ++++++------- tests/generator/generatorprofile.cpp | 16 ++++++------- tests/resources/coverage/generator/model.c | 2 +- tests/resources/coverage/generator/model.h | 2 +- .../generator/model.implementation.out | 2 +- .../coverage/generator/model.interface.out | 2 +- .../generator/model.modified.profile.c | 2 +- .../generator/model.modified.profile.h | 2 +- .../generator/model.modified.profile.py | 2 +- tests/resources/coverage/generator/model.py | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.h | 2 +- .../model.py | 2 +- .../algebraic_eqn_const_var_on_rhs/model.c | 2 +- .../algebraic_eqn_const_var_on_rhs/model.h | 2 +- .../algebraic_eqn_const_var_on_rhs/model.py | 2 +- .../algebraic_eqn_constant_on_rhs/model.c | 2 +- .../algebraic_eqn_constant_on_rhs/model.h | 2 +- .../algebraic_eqn_constant_on_rhs/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs/model.h | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs/model.h | 2 +- .../algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.one.external.c | 2 +- .../model.one.external.h | 2 +- .../model.one.external.py | 2 +- .../model.py | 2 +- .../model.three.externals.c | 2 +- .../model.three.externals.h | 2 +- .../model.three.externals.py | 2 +- .../model.two.externals.c | 2 +- .../model.two.externals.h | 2 +- .../model.two.externals.py | 2 +- .../model.not.ordered.c | 2 +- .../model.not.ordered.h | 2 +- .../model.not.ordered.py | 2 +- .../model.ordered.c | 2 +- .../model.ordered.h | 2 +- .../model.ordered.py | 2 +- .../algebraic_unknown_var_on_rhs/model.c | 2 +- .../algebraic_unknown_var_on_rhs/model.h | 2 +- .../algebraic_unknown_var_on_rhs/model.py | 2 +- .../generator/cell_geometry_model/model.c | 2 +- .../cell_geometry_model/model.external.c | 2 +- .../cell_geometry_model/model.external.h | 2 +- .../cell_geometry_model/model.external.py | 2 +- .../generator/cell_geometry_model/model.h | 2 +- .../generator/cell_geometry_model/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/cellml_slc_example/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../cellml_unit_scaling_constant/model.c | 2 +- .../cellml_unit_scaling_constant/model.h | 2 +- .../cellml_unit_scaling_constant/model.py | 2 +- .../cellml_unit_scaling_rate/model.c | 2 +- .../cellml_unit_scaling_rate/model.h | 2 +- .../cellml_unit_scaling_rate/model.py | 2 +- .../cellml_unit_scaling_state/model.c | 2 +- .../cellml_unit_scaling_state/model.h | 2 +- .../cellml_unit_scaling_state/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../cellml_unit_scaling_voi_direct/model.c | 2 +- .../cellml_unit_scaling_voi_direct/model.h | 2 +- .../cellml_unit_scaling_voi_direct/model.py | 2 +- .../cellml_unit_scaling_voi_indirect/model.c | 2 +- .../cellml_unit_scaling_voi_indirect/model.h | 2 +- .../cellml_unit_scaling_voi_indirect/model.py | 2 +- .../generator/dae_cellml_1_1_model/model.c | 2 +- .../generator/dae_cellml_1_1_model/model.h | 2 +- .../generator/dae_cellml_1_1_model/model.py | 2 +- .../generator/dependent_eqns/model.c | 2 +- .../generator/dependent_eqns/model.h | 2 +- .../generator/dependent_eqns/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.algebraic.c | 2 +- .../model.algebraic.h | 2 +- .../model.algebraic.py | 2 +- .../model.c | 2 +- .../model.computed.constant.c | 2 +- .../model.computed.constant.h | 2 +- .../model.computed.constant.py | 2 +- .../model.constant.c | 2 +- .../model.constant.h | 2 +- .../model.constant.py | 2 +- .../model.dae.c | 2 +- .../model.dae.h | 2 +- .../model.dae.py | 2 +- .../model.dependent.algebraic.c | 2 +- .../model.dependent.algebraic.h | 2 +- .../model.dependent.algebraic.py | 2 +- .../model.dependent.computed.constant.c | 2 +- .../model.dependent.computed.constant.h | 2 +- .../model.dependent.computed.constant.py | 2 +- .../model.dependent.constant.c | 2 +- .../model.dependent.constant.h | 2 +- .../model.dependent.constant.py | 2 +- .../model.dependent.state.c | 2 +- .../model.dependent.state.h | 2 +- .../model.dependent.state.py | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.state.c | 2 +- .../model.state.h | 2 +- .../model.state.py | 2 +- .../generator/noble_model_1962/model.c | 2 +- .../generator/noble_model_1962/model.h | 2 +- .../generator/noble_model_1962/model.py | 2 +- .../generator/ode_computed_var_on_rhs/model.c | 2 +- .../generator/ode_computed_var_on_rhs/model.h | 2 +- .../ode_computed_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/ode_const_var_on_rhs/model.c | 2 +- .../generator/ode_const_var_on_rhs/model.h | 2 +- .../generator/ode_const_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/ode_constant_on_rhs/model.c | 2 +- .../generator/ode_constant_on_rhs/model.h | 2 +- .../generator/ode_constant_on_rhs/model.py | 2 +- .../ode_constant_on_rhs_one_component/model.c | 2 +- .../ode_constant_on_rhs_one_component/model.h | 2 +- .../model.py | 2 +- .../ode_multiple_dependent_odes/model.c | 2 +- .../ode_multiple_dependent_odes/model.h | 2 +- .../ode_multiple_dependent_odes/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../ode_multiple_odes_with_same_name/model.c | 2 +- .../ode_multiple_odes_with_same_name/model.h | 2 +- .../ode_multiple_odes_with_same_name/model.py | 2 +- .../generator/ode_unknown_var_on_rhs/model.c | 2 +- .../generator/ode_unknown_var_on_rhs/model.h | 2 +- .../generator/ode_unknown_var_on_rhs/model.py | 2 +- .../robertson_model_1966/model.dae.c | 2 +- .../robertson_model_1966/model.dae.h | 2 +- .../robertson_model_1966/model.dae.py | 2 +- .../robertson_model_1966/model.ode.c | 2 +- .../robertson_model_1966/model.ode.h | 2 +- .../robertson_model_1966/model.ode.py | 2 +- .../generator/sine_model_imports/model.c | 2 +- .../generator/sine_model_imports/model.h | 2 +- .../generator/sine_model_imports/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- 190 files changed, 216 insertions(+), 216 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 97861c3c3..7adcd24c6 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -705,26 +705,26 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "}\n"; - mInterfaceComputeVariablesMethodFamWoevString = "void computeVariables(double *variables);\n"; - mImplementationComputeVariablesMethodFamWoevString = "void computeVariables(double *variables)\n" + mInterfaceComputeVariablesMethodFamWoevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic);\n"; + mImplementationComputeVariablesMethodFamWoevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n"; - mInterfaceComputeVariablesMethodFamWevString = "void computeVariables(double *variables, ExternalVariable externalVariable);\n"; - mImplementationComputeVariablesMethodFamWevString = "void computeVariables(double *variables, ExternalVariable externalVariable)\n" + mInterfaceComputeVariablesMethodFamWevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n"; + mImplementationComputeVariablesMethodFamWevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n"; - mInterfaceComputeVariablesMethodFdmWoevString = "void computeVariables(double voi, double *states, double *rates, double *variables);\n"; - mImplementationComputeVariablesMethodFdmWoevString = "void computeVariables(double voi, double *states, double *rates, double *variables)\n" + mInterfaceComputeVariablesMethodFdmWoevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n"; + mImplementationComputeVariablesMethodFdmWoevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n"; - mInterfaceComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable);\n"; - mImplementationComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable)\n" + mInterfaceComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n"; + mImplementationComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n"; @@ -1107,22 +1107,22 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceComputeVariablesMethodFamWoevString = ""; mImplementationComputeVariablesMethodFamWoevString = "\n" - "def compute_variables(variables):\n" + "def compute_variables(constants, computedConstants, algebraic):\n" "[CODE]"; mInterfaceComputeVariablesMethodFamWevString = ""; mImplementationComputeVariablesMethodFamWevString = "\n" - "def compute_variables(variables, external_variable):\n" + "def compute_variables(constants, computedConstants, algebraic, external_variable):\n" "[CODE]"; mInterfaceComputeVariablesMethodFdmWoevString = ""; mImplementationComputeVariablesMethodFdmWoevString = "\n" - "def compute_variables(voi, states, rates, variables):\n" + "def compute_variables(voi, states, rates, constants, computedConstants, algebraic):\n" "[CODE]"; mInterfaceComputeVariablesMethodFdmWevString = ""; mImplementationComputeVariablesMethodFdmWevString = "\n" - "def compute_variables(voi, states, rates, variables, external_variable):\n" + "def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable):\n" "[CODE]"; mEmptyMethodString = "pass\n"; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 9d8261e55..ab046ca59 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "47a9b5b8e33ce2fa29c0385e0debe1d295a7e313"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "f171d1553ad485ad286b4a1152bc7d89631750a6"; +static const char C_GENERATOR_PROFILE_SHA1[] = "33b9e23501b734d3e570f1c7252a6fc6c114c126"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "c7620ae1e094506619cae6023f65d4e9f0bd118d"; } // namespace libcellml diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 200b1fc25..2a95c3cbc 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -789,25 +789,25 @@ def test_implementation_compute_variables_method_string(self): g = GeneratorProfile() self.assertEqual( - 'void computeVariables(double *variables)\n{\n[CODE]}\n', + 'void computeVariables(double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', g.implementationComputeVariablesMethodString(False, False)) g.setImplementationComputeVariablesMethodString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(False, False)) self.assertEqual( - 'void computeVariables(double *variables, ExternalVariable externalVariable)\n{\n[CODE]}\n', + 'void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationComputeVariablesMethodString(False, True)) g.setImplementationComputeVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(False, True)) self.assertEqual( - 'void computeVariables(double voi, double *states, double *rates, double *variables)\n{\n[CODE]}\n', + 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', g.implementationComputeVariablesMethodString(True, False)) g.setImplementationComputeVariablesMethodString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(True, False)) self.assertEqual( - 'void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable)\n{\n[CODE]}\n', + 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationComputeVariablesMethodString(True, True)) g.setImplementationComputeVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(True, True)) @@ -1013,25 +1013,25 @@ def test_interface_compute_variables_method_string(self): g = GeneratorProfile() self.assertEqual( - 'void computeVariables(double *variables);\n', + 'void computeVariables(double *constants, double *computedConstants, double *algebraic);\n', g.interfaceComputeVariablesMethodString(False, False)) g.setInterfaceComputeVariablesMethodString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(False, False)) self.assertEqual( - 'void computeVariables(double *variables, ExternalVariable externalVariable);\n', + 'void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n', g.interfaceComputeVariablesMethodString(False, True)) g.setInterfaceComputeVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(False, True)) self.assertEqual( - 'void computeVariables(double voi, double *states, double *rates, double *variables);\n', + 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n', g.interfaceComputeVariablesMethodString(True, False)) g.setInterfaceComputeVariablesMethodString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(True, False)) self.assertEqual( - 'void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable);\n', + 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n', g.interfaceComputeVariablesMethodString(True, True)) g.setInterfaceComputeVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(True, True)) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 739baf735..6fea7d2dc 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -515,33 +515,33 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationComputeRatesMethodString(true)); - EXPECT_EQ("void computeVariables(double *variables);\n", + EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic);\n", generatorProfile->interfaceComputeVariablesMethodString(false, false)); - EXPECT_EQ("void computeVariables(double *variables)\n" + EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationComputeVariablesMethodString(false, false)); - EXPECT_EQ("void computeVariables(double *variables, ExternalVariable externalVariable);\n", + EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n", generatorProfile->interfaceComputeVariablesMethodString(false, true)); - EXPECT_EQ("void computeVariables(double *variables, ExternalVariable externalVariable)\n" + EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationComputeVariablesMethodString(false, true)); - EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *variables);\n", + EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n", generatorProfile->interfaceComputeVariablesMethodString(true, false)); - EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *variables)\n" + EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationComputeVariablesMethodString(true, false)); - EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable);\n", + EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n", generatorProfile->interfaceComputeVariablesMethodString(true, true)); - EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable)\n" + EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 9de875153..da7e34f98 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -600,7 +600,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, variables); } diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 7730315fc..50370dca5 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 9ffecca32..11491a778 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -369,7 +369,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, variables); } diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index efdce8c67..77cb429b1 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -11,4 +11,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index c35f5846f..d4a72bf60 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -600,7 +600,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, variables); } diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 64ce0aa87..0f769b4cb 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index f2c561dfd..19e8c128f 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -598,5 +598,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): find_root_0(voi, states, rates, variables) diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 14f9649a8..7afb5ad30 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -598,5 +598,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): find_root_0(voi, states, rates, variables) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index 54cf101ec..e7a8391fe 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -43,6 +43,6 @@ void computeComputedConstants(double *computedConstants) variables[0] = variables[1]; } -void computeVariables(double *variables) +void computeVariables(double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 7cc4b66ed..fc41e333b 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -42,7 +42,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeVariables(double *variables, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[1] = externalVariable(variables, 1); variables[0] = variables[1]; diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index 4e430ed5c..9ac640aef 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -34,4 +34,4 @@ typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index db4e1a273..781aad578 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -37,6 +37,6 @@ def compute_computed_constants(computed_constants): pass -def compute_variables(variables, external_variable): +def compute_variables(constants, computedConstants, algebraic, external_variable): variables[1] = external_variable(variables, 1) variables[0] = variables[1] diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index 7be31b590..efdd8c3c9 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -31,4 +31,4 @@ void deleteArray(double *array); void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables); +void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index f5a242078..850fd76c9 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -36,5 +36,5 @@ def compute_computed_constants(computed_constants): variables[0] = variables[1] -def compute_variables(variables): +def compute_variables(constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index b3bebf874..67d092981 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -43,6 +43,6 @@ void computeComputedConstants(double *computedConstants) variables[0] = variables[1]; } -void computeVariables(double *variables) +void computeVariables(double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index 7be31b590..efdd8c3c9 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -31,4 +31,4 @@ void deleteArray(double *array); void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables); +void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index d9e835d39..94f2dd4a9 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -36,5 +36,5 @@ def compute_computed_constants(computed_constants): variables[0] = variables[1] -def compute_variables(variables): +def compute_variables(constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index 218da9766..14e40ccee 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -41,6 +41,6 @@ void computeComputedConstants(double *computedConstants) { } -void computeVariables(double *variables) +void computeVariables(double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index 230086c60..1f4d1dcf9 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -31,4 +31,4 @@ void deleteArray(double *array); void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables); +void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index a0f283790..f51bc9ecb 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -35,5 +35,5 @@ def compute_computed_constants(computed_constants): pass -def compute_variables(variables): +def compute_variables(constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 9b3bafb89..dd7546549 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -66,7 +66,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = variables[0]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[1] = rates[0]; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index d05526b0f..7b9fab8b6 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index fab4c53eb..7cff7aaaa 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -54,5 +54,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[1] = rates[0] diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 1c98887b5..999d76aa5 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -66,7 +66,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = variables[0]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[1] = rates[0]; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index 7f86bfafd..94a64dfa8 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 5a1db9e80..0e55e6b5b 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -54,5 +54,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[1] = rates[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 4539a94e6..3074a08bb 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -66,7 +66,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = variables[0]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[1] = 2.0*states[0]; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index 687e4f315..9c395a3d4 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 59f13819a..50cfc4e9f 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -54,5 +54,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[1] = 2.0*states[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 3a124f662..6a004da95 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -66,7 +66,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = variables[0]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[1] = 2.0*states[0]; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index b30eab519..50c681f14 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 1ed616c4f..353cea9ff 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -54,5 +54,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[1] = 2.0*states[0] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index fdf043a00..7b9e360fc 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -75,7 +75,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeVariables(double *variables) +void computeVariables(double *constants, double *computedConstants, double *algebraic) { findRoot0(variables); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index 300066fb2..eda59a04a 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -47,7 +47,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeVariables(double *variables, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[3] = externalVariable(variables, 3); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index 4e430ed5c..9ac640aef 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -34,4 +34,4 @@ typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 2f516f834..44d1589f0 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -42,5 +42,5 @@ def compute_computed_constants(computed_constants): pass -def compute_variables(variables, external_variable): +def compute_variables(constants, computedConstants, algebraic, external_variable): variables[3] = external_variable(variables, 3) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index 7be31b590..efdd8c3c9 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -31,4 +31,4 @@ void deleteArray(double *array); void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables); +void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 3f07e38d5..98a491a2c 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -62,5 +62,5 @@ def compute_computed_constants(computed_constants): pass -def compute_variables(variables): +def compute_variables(constants, computedConstants, algebraic): find_root_0(variables) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index 3f08eb363..c2c0ceb69 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -81,7 +81,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeVariables(double *variables) +void computeVariables(double *constants, double *computedConstants, double *algebraic) { findRoot0(variables); } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index 95cddbeb4..7850afa8d 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -31,4 +31,4 @@ void deleteArray(double *array); void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables); +void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c index 379ddae4e..83641270b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c @@ -78,7 +78,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeVariables(double *variables, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = externalVariable(variables, 0); findRoot0(variables); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h index df0655d6f..ffc06e13b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h @@ -34,4 +34,4 @@ typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py index d51f24510..c0ea0719e 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py @@ -66,6 +66,6 @@ def compute_computed_constants(computed_constants): pass -def compute_variables(variables, external_variable): +def compute_variables(constants, computedConstants, algebraic, external_variable): variables[0] = external_variable(variables, 0) find_root_0(variables) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index ad98c51d7..0444e0091 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -68,5 +68,5 @@ def compute_computed_constants(computed_constants): pass -def compute_variables(variables): +def compute_variables(constants, computedConstants, algebraic): find_root_0(variables) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index 7cbf8256a..38b9632cd 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -45,7 +45,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeVariables(double *variables, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = externalVariable(variables, 0); variables[1] = externalVariable(variables, 1); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index df0655d6f..ffc06e13b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -34,4 +34,4 @@ typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index bf285d55d..c9f380a65 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -40,7 +40,7 @@ def compute_computed_constants(computed_constants): pass -def compute_variables(variables, external_variable): +def compute_variables(constants, computedConstants, algebraic, external_variable): variables[0] = external_variable(variables, 0) variables[1] = external_variable(variables, 1) variables[2] = external_variable(variables, 2) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c index 9be838cc4..93170385b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c @@ -115,7 +115,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeVariables(double *variables, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = externalVariable(variables, 0); variables[2] = externalVariable(variables, 2); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h index df0655d6f..ffc06e13b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h @@ -34,4 +34,4 @@ typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py index 2001d6080..0c5fbd0d1 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py @@ -97,7 +97,7 @@ def compute_computed_constants(computed_constants): pass -def compute_variables(variables, external_variable): +def compute_variables(constants, computedConstants, algebraic, external_variable): variables[0] = external_variable(variables, 0) variables[2] = external_variable(variables, 2) find_root_0(variables) diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index fc3136279..7988fd4d9 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -82,7 +82,7 @@ void computeComputedConstants(double *computedConstants) variables[3] = 3.0*variables[4]+variables[5]; } -void computeVariables(double *variables) +void computeVariables(double *constants, double *computedConstants, double *algebraic) { findRoot0(variables); variables[0] = variables[1]+variables[2]; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index 95cddbeb4..7850afa8d 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -31,4 +31,4 @@ void deleteArray(double *array); void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables); +void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 389dbfc4d..732e69482 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -68,6 +68,6 @@ def compute_computed_constants(computed_constants): variables[3] = 3.0*variables[4]+variables[5] -def compute_variables(variables): +def compute_variables(constants, computedConstants, algebraic): find_root_0(variables) variables[0] = variables[1]+variables[2] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index 35fe86e31..1f97af5bd 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -82,7 +82,7 @@ void computeComputedConstants(double *computedConstants) variables[0] = 3.0*variables[1]+variables[2]; } -void computeVariables(double *variables) +void computeVariables(double *constants, double *computedConstants, double *algebraic) { findRoot0(variables); variables[5] = variables[4]+variables[3]; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index 95cddbeb4..7850afa8d 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -31,4 +31,4 @@ void deleteArray(double *array); void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables); +void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index ec5c0bbf2..eb228d40b 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -68,6 +68,6 @@ def compute_computed_constants(computed_constants): variables[0] = 3.0*variables[1]+variables[2] -def compute_variables(variables): +def compute_variables(constants, computedConstants, algebraic): find_root_0(variables) variables[5] = variables[4]+variables[3] diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index e02a8b142..b587e3aaa 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -43,6 +43,6 @@ void computeComputedConstants(double *computedConstants) variables[1] = variables[0]; } -void computeVariables(double *variables) +void computeVariables(double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index 230086c60..1f4d1dcf9 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -31,4 +31,4 @@ void deleteArray(double *array); void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables); +void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index a273db38c..40a75154a 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -36,5 +36,5 @@ def compute_computed_constants(computed_constants): variables[1] = variables[0] -def compute_variables(variables): +def compute_variables(constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index b69bd0e05..eb98bbb19 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -47,6 +47,6 @@ void computeComputedConstants(double *computedConstants) variables[3] = 0.02*variables[0]; } -void computeVariables(double *variables) +void computeVariables(double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 3ceea7e7a..c9196c88c 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -45,7 +45,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeVariables(double *variables, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[1] = externalVariable(variables, 1); variables[2] = externalVariable(variables, 2); diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 86e769ee4..4ff6fcadf 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -34,4 +34,4 @@ typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 3d69c78ed..a186a0405 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -40,7 +40,7 @@ def compute_computed_constants(computed_constants): pass -def compute_variables(variables, external_variable): +def compute_variables(constants, computedConstants, algebraic, external_variable): variables[1] = external_variable(variables, 1) variables[2] = external_variable(variables, 2) variables[0] = 1000.0*3.14*variables[2]*variables[2]*variables[1] diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index 882e0d6ab..2a61e0d91 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -31,4 +31,4 @@ void deleteArray(double *array); void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables); +void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index 48ad53c10..eeb43ec56 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -40,5 +40,5 @@ def compute_computed_constants(computed_constants): variables[3] = 0.02*variables[0] -def compute_variables(variables): +def compute_variables(constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index c4d18d612..95661b3c6 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -68,7 +68,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = states[1]*1.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0); variables[1] = 2.0*states[1]; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index edaae29a0..00bb5bd45 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index dc65de94a..70c4e2d23 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -56,6 +56,6 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = states[1]*1.0 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0) variables[1] = 2.0*states[1] diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index 4afceca0c..671757fcc 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -52,5 +52,5 @@ def compute_computed_constants(computed_constants): variables[0] = variables[1]*(variables[2]*variables[3]-variables[4]*variables[5])/(variables[6]*variables[5]+variables[9]*variables[3]+variables[8]*variables[5]*variables[3]+variables[7]) -def compute_variables(variables): +def compute_variables(constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index 3475b85d5..7b504d866 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -65,6 +65,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = 1.23; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index 3c03deb82..8c3626ccd 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index d0b35c939..3e187a330 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -53,5 +53,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.23 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 790526d9c..263e235ef 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -45,6 +45,6 @@ void computeComputedConstants(double *computedConstants) variables[2] = 0.001*variables[0]+0.001*variables[0]; } -void computeVariables(double *variables) +void computeVariables(double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index 5499853e3..c00e1f999 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -31,4 +31,4 @@ void deleteArray(double *array); void initialiseVariables(double *constants); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables); +void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index 7a674f901..0225aaf9a 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -38,5 +38,5 @@ def compute_computed_constants(computed_constants): variables[2] = 0.001*variables[0]+0.001*variables[0] -def compute_variables(variables): +def compute_variables(constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 9af4c26b6..34036c90a 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -65,7 +65,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = 1.23; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[0] = 1000.0*rates[0]+1000.0*rates[0]; variables[1] = 1000.0*0.001*rates[0]+1000.0*0.001*rates[0]; diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index 3c03deb82..8c3626ccd 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 81b99cccc..758d11eb0 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -53,6 +53,6 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.23 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[0] = 1000.0*rates[0]+1000.0*rates[0] variables[1] = 1000.0*0.001*rates[0]+1000.0*0.001*rates[0] diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index d89ec5205..1237bfea4 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -65,7 +65,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = 1.23; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[0] = states[0]+states[0]; variables[1] = 0.001*states[0]+0.001*states[0]; diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index 3c03deb82..8c3626ccd 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index 8ea99efc5..5587cbfc4 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -53,6 +53,6 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.23 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[0] = states[0]+states[0] variables[1] = 0.001*states[0]+0.001*states[0] diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index a369dea89..9a27a9d83 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -66,6 +66,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = 7.89; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index 6a04a2fbc..dd033a99a 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index 1217a8d8a..1f6f1d4ba 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -54,5 +54,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = 7.89 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index 3300a1507..7b0c4b31f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -70,6 +70,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = 7.89; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 4c3949f2a..973e179a4 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 9db1db120..f036cd72f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -58,5 +58,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = 7.89 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index 01ebcf426..f283bf9e3 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -66,6 +66,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = 0.001*voi/1.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index 0bccaf5c8..a4444473c 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index 98608474d..01562a7bf 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -54,5 +54,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = 0.001*voi/1.0 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index 3001a87e8..523518350 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -69,6 +69,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[2] = 0.001*13.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index e39db828a..b79936bf9 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index 3571fc789..cdc67162d 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -57,5 +57,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[2] = 0.001*13.0 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 30a8c5729..35ff65347 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -146,7 +146,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = variables[6]/variables[9]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[2] = states[1]+variables[3]; findRoot0(voi, states, rates, variables); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 23a61c61e..3b1c8ced6 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index f0c69dd15..463eee85f 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -121,7 +121,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = variables[6]/variables[9] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[2] = states[1]+variables[3] find_root_0(voi, states, rates, variables) variables[4] = states[0]/variables[7] diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 670fcf620..c9fc847af 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -65,7 +65,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[1] = 2.0*voi; variables[0] = 3.0*variables[1]; diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 529dbd03f..ebcf19ae6 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index a48ff4587..f8022992a 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -53,6 +53,6 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[1] = 2.0*voi variables[0] = 3.0*variables[1] diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 488858b66..b9184e392 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -588,7 +588,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[32] = (variables[215]-states[32])/variables[216]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[5] = states[1]; variables[2] = variables[3]*log(variables[4]/variables[5]); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index c0a9edbff..812d0c653 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 9306dbef6..654449425 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -595,7 +595,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[32] = (variables[215]-states[32])/variables[216] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[5] = states[1] variables[2] = variables[3]*log(variables[4]/variables[5]) variables[9] = 0.5*variables[3]*log(variables[10]/states[0]) diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 67fc7303c..27fc1673a 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -475,7 +475,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[14] = variables[183]*(1.0-states[14])-variables[184]*states[14]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[13] = variables[25]*(states[0]-variables[32]); variables[11] = variables[33]*(states[0]-variables[40]); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index c574f5af0..d709dca8d 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 73447539d..180b55d8b 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -470,7 +470,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[14] = variables[183]*(1.0-states[14])-variables[184]*states[14] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[13] = variables[25]*(states[0]-variables[32]) variables[11] = variables[33]*(states[0]-variables[40]) variables[12] = variables[41]*(states[0]-variables[48]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 76221f43e..c6af41ab9 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -109,7 +109,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = externalVariable(voi, states, rates, variables, 0); variables[1] = variables[7]*(states[0]-variables[6]); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index b85f55026..d621ba0e6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -41,4 +41,4 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index ec1244d2f..f8a6f44c9 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -109,7 +109,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, variables, external_variable): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[0] = external_variable(voi, states, rates, variables, 0) variables[1] = variables[7]*(states[0]-variables[6]) variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index bfc76d2c8..df2a57cad 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -108,7 +108,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[1] = variables[7]*(states[0]-variables[6]); variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 22550c76d..cb6482372 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -109,7 +109,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[6] = externalVariable(voi, states, rates, variables, 6); variables[1] = variables[7]*(states[0]-variables[6]); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index b85f55026..d621ba0e6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -41,4 +41,4 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 31eb6b9db..03186b165 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -109,7 +109,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, variables, external_variable): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[6] = external_variable(voi, states, rates, variables, 6) variables[1] = variables[7]*(states[0]-variables[6]) variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 2ec875f7c..b87f3589f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -109,7 +109,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[1] = variables[7]*(states[0]-variables[6]); variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index b85f55026..d621ba0e6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -41,4 +41,4 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 6db074dda..47b39189c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -109,7 +109,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, variables, external_variable): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[1] = variables[7]*(states[0]-variables[6]) variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 8b8dee0b3..eec3389de 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -543,7 +543,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot1(voi, states, rates, variables); } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, variables); findRoot2(voi, states, rates, variables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index ef02301bd..1090a6d03 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 0f940110a..110c926fb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -485,7 +485,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): find_root_1(voi, states, rates, variables) -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): find_root_0(voi, states, rates, variables) find_root_2(voi, states, rates, variables) find_root_3(voi, states, rates, variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index b50aa4b59..3abf7d45a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -110,7 +110,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[17] = externalVariable(voi, states, rates, variables, 17); variables[0] = externalVariable(voi, states, rates, variables, 0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index b85f55026..d621ba0e6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -41,4 +41,4 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 53d4e89f8..2ca6db189 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -110,7 +110,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, variables, external_variable): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[17] = external_variable(voi, states, rates, variables, 17) variables[0] = external_variable(voi, states, rates, variables, 0) variables[1] = variables[7]*(states[0]-variables[6]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 89553d7e3..13087c293 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -110,7 +110,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[14] = externalVariable(voi, states, rates, variables, 14); variables[5] = externalVariable(voi, states, rates, variables, 5); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index b85f55026..d621ba0e6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -41,4 +41,4 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 6b5f48f3a..2b2d655ac 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -111,7 +111,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, variables, external_variable): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[14] = external_variable(voi, states, rates, variables, 14) variables[5] = external_variable(voi, states, rates, variables, 5) variables[6] = variables[5]-10.613 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 9577016c1..93afb3d88 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -110,7 +110,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[1] = variables[7]*(states[0]-variables[6]); variables[9] = externalVariable(voi, states, rates, variables, 9); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index b85f55026..d621ba0e6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -41,4 +41,4 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 316463d2b..c47a5f3ed 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -110,7 +110,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, variables, external_variable): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[1] = variables[7]*(states[0]-variables[6]) variables[9] = external_variable(voi, states, rates, variables, 9) variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 84f5c32d2..47ff51ec8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -101,7 +101,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = variables[18]*(1.0-states[1])-variables[19]*states[1]; } -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; variables[1] = externalVariable(voi, states, rates, variables, 1); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index b85f55026..d621ba0e6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -41,4 +41,4 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 0b8179640..72b212b89 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -101,7 +101,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[1] = variables[18]*(1.0-states[1])-variables[19]*states[1] -def compute_variables(voi, states, rates, variables, external_variable): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[1] = external_variable(voi, states, rates, variables, 1) variables[2] = variables[8]*(variables[1]-variables[7]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index e5a954f65..f936897d5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -106,7 +106,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[2] = variables[17]*(1.0-states[2])-variables[18]*states[2]; } -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; variables[1] = externalVariable(voi, states, rates, variables, 1); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index b85f55026..d621ba0e6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -41,4 +41,4 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 80610b753..6b77efdbc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -106,7 +106,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[2] = variables[17]*(1.0-states[2])-variables[18]*states[2] -def compute_variables(voi, states, rates, variables, external_variable): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[1] = external_variable(voi, states, rates, variables, 1) variables[2] = variables[8]*(variables[1]-variables[7]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index ef02301bd..1090a6d03 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index ef8e528bf..6c0ce45df 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -107,7 +107,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[1] = variables[7]*(states[0]-variables[6]) variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 27a4df313..ed301760a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -106,7 +106,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[2] = variables[17]*(1.0-states[2])-variables[18]*states[2]; } -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[1] = variables[7]*(states[0]-variables[6]); variables[10] = externalVariable(voi, states, rates, variables, 10); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index b85f55026..d621ba0e6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -41,4 +41,4 @@ typedef double (* ExternalVariable)(double voi, double *states, double *rates, d void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *variables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index fbbf62426..e110f1e76 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -106,7 +106,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[2] = variables[17]*(1.0-states[2])-variables[18]*states[2] -def compute_variables(voi, states, rates, variables, external_variable): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): variables[1] = variables[7]*(states[0]-variables[6]) variables[10] = external_variable(voi, states, rates, variables, 10) variables[3] = variables[9]*pow(variables[10], 3.0)*states[1]*(states[0]-variables[8]) diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 2811d042f..1029459d2 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -106,7 +106,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = variables[15]*(1.0-states[3])-variables[16]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[1] = variables[4]*(states[0]-variables[5]); variables[6] = pow(states[1], 3.0)*states[2]*variables[7]; diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index d6958fd5d..10555c803 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 36858282f..1d18b097a 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -94,7 +94,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[3] = variables[15]*(1.0-states[3])-variables[16]*states[3] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[1] = variables[4]*(states[0]-variables[5]) variables[6] = pow(states[1], 3.0)*states[2]*variables[7] variables[0] = (variables[6]+0.14)*(states[0]-variables[8]) diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index f6c4d954c..621132fc1 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -65,6 +65,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = variables[0]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index 0bccaf5c8..a4444473c 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index b3ac9c62f..906bdb3f8 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -53,5 +53,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 7f30100d5..48b06bdb4 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -65,6 +65,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = variables[0]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index 7f86bfafd..94a64dfa8 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 2dc19f393..1ddea11e3 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -53,5 +53,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index d630e604a..8f42444b8 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -65,6 +65,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = variables[0]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index 0bccaf5c8..a4444473c 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index ae0d7b060..2d88bb4b2 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -53,5 +53,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index ddb0e28f9..7a5d40207 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -65,6 +65,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = variables[0]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index 7f86bfafd..94a64dfa8 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index ad34a0c19..78fbcf40b 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -53,5 +53,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index cc6439e9b..a6d0ec5dc 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -63,6 +63,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index 0bccaf5c8..a4444473c 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index 58f3ce266..206392ff3 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -51,5 +51,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 3cfebdce4..2c479d28d 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -63,6 +63,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index 7f86bfafd..94a64dfa8 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index 0a9a86dba..ee87c9c26 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -51,5 +51,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 1.0 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index eb5bd6f89..5a14fd1ca 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -68,6 +68,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index 72fe9729b..1653e2e60 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 9b6c3efa3..6e3ba6e67 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -56,5 +56,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index aab636ab1..1aedd5274 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -68,6 +68,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index 2751faf2a..b26a181c2 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 566c040ff..9f48dedb9 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -56,5 +56,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index a372b5ab9..0ecc275fc 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -68,6 +68,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = variables[0]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index d0b018b6f..9ef0b6b75 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index c57a7c020..3b68bcdfd 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -56,5 +56,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = variables[0] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index dc292a96c..90dde15f7 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -66,6 +66,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = states[0]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index 0bccaf5c8..a4444473c 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 24271e0b3..aaaa0e947 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -54,5 +54,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = states[0] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index ff9bd2d42..d0edf14b0 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -110,7 +110,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = variables[0]*states[0]-variables[3]*pow(states[1], 2.0)-variables[1]*states[1]*variables[2]; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, variables); variables[4] = 10000.0*states[1]; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index 4b40d5fc5..9e43acde3 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index d325fee60..147a5f9f1 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -88,6 +88,6 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = variables[0]*states[0]-variables[3]*pow(states[1], 2.0)-variables[1]*states[1]*variables[2] -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): find_root_0(voi, states, rates, variables) variables[4] = 10000.0*states[1] diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index cdea39537..8ef049b2a 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -76,7 +76,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = variables[2]*pow(states[2], 2.0); } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[3] = 10000.0*states[2]; } diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index 4b40d5fc5..9e43acde3 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 653a16bd6..16be8a4e3 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -64,5 +64,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = variables[2]*pow(states[2], 2.0) -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[3] = 10000.0*states[2] diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index cc9ad3939..e81c50d4d 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -80,7 +80,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = cos(voi); } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { variables[0] = sin(voi); variables[9] = (voi < variables[6])?voi*variables[4]-0.5:(voi < variables[7])?(3.14159265358979-voi)*variables[4]-0.5:(voi < variables[8])?(voi-3.14159265358979)*variables[4]-0.5:(variables[5]-voi)*variables[4]-0.5; diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index 175f6e2a0..d1e57debe 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 75e2a697f..d4551dbb9 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -72,7 +72,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = cos(voi) -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): variables[0] = sin(voi) variables[9] = voi*variables[4]-0.5 if lt_func(voi, variables[6]) else (3.14159265358979-voi)*variables[4]-0.5 if lt_func(voi, variables[7]) else (voi-3.14159265358979)*variables[4]-0.5 if lt_func(voi, variables[8]) else (variables[5]-voi)*variables[4]-0.5 variables[2] = -variables[9]*variables[9]+variables[3]+variables[9] if lt_func(voi, variables[6]) else -variables[9]*variables[9]+variables[3]+variables[9] if lt_func(voi, variables[7]) else variables[9]*variables[9]-variables[3]-variables[9] if lt_func(voi, variables[8]) else variables[9]*variables[9]-variables[3]-variables[9] diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index f8e4ac81c..b31c10168 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -58,7 +58,7 @@ void computeComputedConstants(double *computedConstants) { } -void computeVariables(double *variables, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { variables[9] = externalVariable(variables, 9); variables[0] = variables[1]*(variables[2]*variables[3]-variables[4]*variables[5])/(variables[6]*variables[5]+variables[9]*variables[3]+variables[8]*variables[5]*variables[3]+variables[7]); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index d8442ae9e..34f0b0874 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -34,4 +34,4 @@ typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); void computeComputedConstants(double *computedConstants); -void computeVariables(double *variables, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 7c13d97e3..b945a7642 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -53,6 +53,6 @@ def compute_computed_constants(computed_constants): pass -def compute_variables(variables, external_variable): +def compute_variables(constants, computedConstants, algebraic, external_variable): variables[9] = external_variable(variables, 9) variables[0] = variables[1]*(variables[2]*variables[3]-variables[4]*variables[5])/(variables[6]*variables[5]+variables[9]*variables[3]+variables[8]*variables[5]*variables[3]+variables[7]) diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 0d7a8cae4..1dc483fff 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -65,6 +65,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[0] = 3.0; } -void computeVariables(double voi, double *states, double *rates, double *variables) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index 8e703e9d2..c138b0f36 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -38,4 +38,4 @@ void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); void computeComputedConstants(double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *variables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index bbaccf6f6..3982c84aa 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -53,5 +53,5 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[0] = 3.0 -def compute_variables(voi, states, rates, variables): +def compute_variables(voi, states, rates, constants, computedConstants, algebraic): pass From 8488c494627fafaaf67e94f3c450741f0b932d5a Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 7 Aug 2024 17:04:21 +0200 Subject: [PATCH 06/74] Generator: use different arrays for constants, computed constants, and algebraic variables for computeComputedConstants(). --- src/generatorprofile.cpp | 6 +++--- src/generatorprofilesha1values.h | 4 ++-- tests/bindings/python/test_generator_profile.py | 4 ++-- tests/generator/generatorprofile.cpp | 4 ++-- tests/resources/coverage/generator/model.c | 2 +- tests/resources/coverage/generator/model.h | 2 +- tests/resources/coverage/generator/model.implementation.out | 2 +- tests/resources/coverage/generator/model.interface.out | 2 +- tests/resources/coverage/generator/model.modified.profile.c | 2 +- tests/resources/coverage/generator/model.modified.profile.h | 2 +- .../resources/coverage/generator/model.modified.profile.py | 2 +- tests/resources/coverage/generator/model.out | 2 +- tests/resources/coverage/generator/model.py | 2 +- .../generator/algebraic_eqn_computed_var_on_rhs/model.c | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.external.c | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.external.h | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.external.py | 2 +- .../generator/algebraic_eqn_computed_var_on_rhs/model.h | 2 +- .../generator/algebraic_eqn_computed_var_on_rhs/model.py | 2 +- .../generator/algebraic_eqn_const_var_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_const_var_on_rhs/model.h | 2 +- .../generator/algebraic_eqn_const_var_on_rhs/model.py | 2 +- .../generator/algebraic_eqn_constant_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_constant_on_rhs/model.h | 2 +- .../generator/algebraic_eqn_constant_on_rhs/model.py | 2 +- .../generator/algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_derivative_on_rhs/model.h | 2 +- .../generator/algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs_one_component/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs_one_component/model.h | 2 +- .../algebraic_eqn_derivative_on_rhs_one_component/model.py | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.h | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../algebraic_eqn_state_var_on_rhs_one_component/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs_one_component/model.h | 2 +- .../algebraic_eqn_state_var_on_rhs_one_component/model.py | 2 +- .../algebraic_eqn_with_one_non_isolated_unknown/model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../algebraic_eqn_with_one_non_isolated_unknown/model.h | 2 +- .../algebraic_eqn_with_one_non_isolated_unknown/model.py | 2 +- .../algebraic_system_with_three_linked_unknowns/model.c | 2 +- .../algebraic_system_with_three_linked_unknowns/model.h | 2 +- .../model.one.external.c | 2 +- .../model.one.external.h | 2 +- .../model.one.external.py | 2 +- .../algebraic_system_with_three_linked_unknowns/model.py | 2 +- .../model.three.externals.c | 2 +- .../model.three.externals.h | 2 +- .../model.three.externals.py | 2 +- .../model.two.externals.c | 2 +- .../model.two.externals.h | 2 +- .../model.two.externals.py | 2 +- .../model.not.ordered.c | 2 +- .../model.not.ordered.h | 2 +- .../model.not.ordered.py | 2 +- .../model.ordered.c | 2 +- .../model.ordered.h | 2 +- .../model.ordered.py | 2 +- .../generator/algebraic_unknown_var_on_rhs/model.c | 2 +- .../generator/algebraic_unknown_var_on_rhs/model.h | 2 +- .../generator/algebraic_unknown_var_on_rhs/model.py | 2 +- tests/resources/generator/cell_geometry_model/model.c | 2 +- .../generator/cell_geometry_model/model.external.c | 2 +- .../generator/cell_geometry_model/model.external.h | 2 +- .../generator/cell_geometry_model/model.external.py | 2 +- tests/resources/generator/cell_geometry_model/model.h | 2 +- tests/resources/generator/cell_geometry_model/model.py | 2 +- .../generator/cellml_mappings_and_encapsulations/model.c | 2 +- .../generator/cellml_mappings_and_encapsulations/model.h | 2 +- .../generator/cellml_mappings_and_encapsulations/model.py | 2 +- tests/resources/generator/cellml_slc_example/model.py | 2 +- .../cellml_state_initialised_using_variable/model.c | 2 +- .../cellml_state_initialised_using_variable/model.h | 2 +- .../cellml_state_initialised_using_variable/model.py | 2 +- .../generator/cellml_unit_scaling_constant/model.c | 2 +- .../generator/cellml_unit_scaling_constant/model.h | 2 +- .../generator/cellml_unit_scaling_constant/model.py | 2 +- tests/resources/generator/cellml_unit_scaling_rate/model.c | 2 +- tests/resources/generator/cellml_unit_scaling_rate/model.h | 2 +- tests/resources/generator/cellml_unit_scaling_rate/model.py | 2 +- tests/resources/generator/cellml_unit_scaling_state/model.c | 2 +- tests/resources/generator/cellml_unit_scaling_state/model.h | 2 +- .../resources/generator/cellml_unit_scaling_state/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.c | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.h | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.py | 2 +- .../generator/cellml_unit_scaling_voi_indirect/model.c | 2 +- .../generator/cellml_unit_scaling_voi_indirect/model.h | 2 +- .../generator/cellml_unit_scaling_voi_indirect/model.py | 2 +- tests/resources/generator/dae_cellml_1_1_model/model.c | 2 +- tests/resources/generator/dae_cellml_1_1_model/model.h | 2 +- tests/resources/generator/dae_cellml_1_1_model/model.py | 2 +- tests/resources/generator/dependent_eqns/model.c | 2 +- tests/resources/generator/dependent_eqns/model.h | 2 +- tests/resources/generator/dependent_eqns/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.algebraic.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.algebraic.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.algebraic.py | 2 +- .../generator/hodgkin_huxley_squid_axon_model_1952/model.c | 2 +- .../model.computed.constant.c | 2 +- .../model.computed.constant.h | 2 +- .../model.computed.constant.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.constant.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.constant.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.constant.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.py | 2 +- .../model.dependent.algebraic.c | 2 +- .../model.dependent.algebraic.h | 2 +- .../model.dependent.algebraic.py | 2 +- .../model.dependent.computed.constant.c | 2 +- .../model.dependent.computed.constant.h | 2 +- .../model.dependent.computed.constant.py | 2 +- .../model.dependent.constant.c | 2 +- .../model.dependent.constant.h | 2 +- .../model.dependent.constant.py | 2 +- .../model.dependent.state.c | 2 +- .../model.dependent.state.h | 2 +- .../model.dependent.state.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.external.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.external.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.external.py | 2 +- .../generator/hodgkin_huxley_squid_axon_model_1952/model.h | 2 +- .../generator/hodgkin_huxley_squid_axon_model_1952/model.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.state.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.state.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.state.py | 2 +- tests/resources/generator/noble_model_1962/model.c | 2 +- tests/resources/generator/noble_model_1962/model.h | 2 +- tests/resources/generator/noble_model_1962/model.py | 2 +- tests/resources/generator/ode_computed_var_on_rhs/model.c | 2 +- tests/resources/generator/ode_computed_var_on_rhs/model.h | 2 +- tests/resources/generator/ode_computed_var_on_rhs/model.py | 2 +- .../generator/ode_computed_var_on_rhs_one_component/model.c | 2 +- .../generator/ode_computed_var_on_rhs_one_component/model.h | 2 +- .../ode_computed_var_on_rhs_one_component/model.py | 2 +- tests/resources/generator/ode_const_var_on_rhs/model.c | 2 +- tests/resources/generator/ode_const_var_on_rhs/model.h | 2 +- tests/resources/generator/ode_const_var_on_rhs/model.py | 2 +- .../generator/ode_const_var_on_rhs_one_component/model.c | 2 +- .../generator/ode_const_var_on_rhs_one_component/model.h | 2 +- .../generator/ode_const_var_on_rhs_one_component/model.py | 2 +- tests/resources/generator/ode_constant_on_rhs/model.c | 2 +- tests/resources/generator/ode_constant_on_rhs/model.h | 2 +- tests/resources/generator/ode_constant_on_rhs/model.py | 2 +- .../generator/ode_constant_on_rhs_one_component/model.c | 2 +- .../generator/ode_constant_on_rhs_one_component/model.h | 2 +- .../generator/ode_constant_on_rhs_one_component/model.py | 2 +- .../resources/generator/ode_multiple_dependent_odes/model.c | 2 +- .../resources/generator/ode_multiple_dependent_odes/model.h | 2 +- .../generator/ode_multiple_dependent_odes/model.py | 2 +- .../ode_multiple_dependent_odes_one_component/model.c | 2 +- .../ode_multiple_dependent_odes_one_component/model.h | 2 +- .../ode_multiple_dependent_odes_one_component/model.py | 2 +- .../generator/ode_multiple_odes_with_same_name/model.c | 2 +- .../generator/ode_multiple_odes_with_same_name/model.h | 2 +- .../generator/ode_multiple_odes_with_same_name/model.py | 2 +- tests/resources/generator/ode_unknown_var_on_rhs/model.c | 2 +- tests/resources/generator/ode_unknown_var_on_rhs/model.h | 2 +- tests/resources/generator/ode_unknown_var_on_rhs/model.py | 2 +- tests/resources/generator/robertson_model_1966/model.dae.c | 2 +- tests/resources/generator/robertson_model_1966/model.dae.h | 2 +- tests/resources/generator/robertson_model_1966/model.dae.py | 2 +- tests/resources/generator/robertson_model_1966/model.ode.c | 2 +- tests/resources/generator/robertson_model_1966/model.ode.h | 2 +- tests/resources/generator/robertson_model_1966/model.ode.py | 2 +- tests/resources/generator/sine_model_imports/model.c | 2 +- tests/resources/generator/sine_model_imports/model.h | 2 +- tests/resources/generator/sine_model_imports/model.py | 2 +- .../generator/unknown_variable_as_external_variable/model.c | 2 +- .../generator/unknown_variable_as_external_variable/model.h | 2 +- .../unknown_variable_as_external_variable/model.py | 2 +- .../generator/variable_initialised_using_a_constant/model.c | 2 +- .../generator/variable_initialised_using_a_constant/model.h | 2 +- .../variable_initialised_using_a_constant/model.py | 2 +- 191 files changed, 196 insertions(+), 196 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 7adcd24c6..0c17c44b8 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -689,8 +689,8 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "}\n"; - mInterfaceComputeComputedConstantsMethodString = "void computeComputedConstants(double *computedConstants);\n"; - mImplementationComputeComputedConstantsMethodString = "void computeComputedConstants(double *computedConstants)\n" + mInterfaceComputeComputedConstantsMethodString = "void computeComputedConstants(double *constants, double *computedConstants);\n"; + mImplementationComputeComputedConstantsMethodString = "void computeComputedConstants(double *constants, double *computedConstants)\n" "{\n" "[CODE]" "}\n"; @@ -1092,7 +1092,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceComputeComputedConstantsMethodString = ""; mImplementationComputeComputedConstantsMethodString = "\n" - "def compute_computed_constants(computed_constants):\n" + "def compute_computed_constants(constants, computed_constants):\n" "[CODE]"; mInterfaceComputeRatesMethodWoevString = ""; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index ab046ca59..ba936cc96 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "33b9e23501b734d3e570f1c7252a6fc6c114c126"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "c7620ae1e094506619cae6023f65d4e9f0bd118d"; +static const char C_GENERATOR_PROFILE_SHA1[] = "2e1a7d8b5995845aceceeb06e8f084f9e11fa13d"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "c7d3866a8238ce15df79bf48d83b95c0650de2b4"; } // namespace libcellml diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 2a95c3cbc..8749ef922 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -761,7 +761,7 @@ def test_implementation_compute_computed_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void computeComputedConstants(double *computedConstants)\n{\n[CODE]}\n', + self.assertEqual('void computeComputedConstants(double *constants, double *computedConstants)\n{\n[CODE]}\n', g.implementationComputeComputedConstantsMethodString()) g.setImplementationComputeComputedConstantsMethodString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeComputedConstantsMethodString()) @@ -985,7 +985,7 @@ def test_interface_compute_computed_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void computeComputedConstants(double *computedConstants);\n', + self.assertEqual('void computeComputedConstants(double *constants, double *computedConstants);\n', g.interfaceComputeComputedConstantsMethodString()) g.setInterfaceComputeComputedConstantsMethodString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeComputedConstantsMethodString()) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 6fea7d2dc..bde173bdc 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -491,9 +491,9 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationInitialiseVariablesMethodString(true, true)); - EXPECT_EQ("void computeComputedConstants(double *computedConstants);\n", + EXPECT_EQ("void computeComputedConstants(double *constants, double *computedConstants);\n", generatorProfile->interfaceComputeComputedConstantsMethodString()); - EXPECT_EQ("void computeComputedConstants(double *computedConstants)\n" + EXPECT_EQ("void computeComputedConstants(double *constants, double *computedConstants)\n" "{\n" "[CODE]" "}\n", diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index da7e34f98..9d74d7671 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -403,7 +403,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[0] = variables[1] == variables[2]; variables[3] = variables[1]/(variables[2] == variables[2]); diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 50370dca5..e05872689 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 11491a778..35809a2b2 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -172,7 +172,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[0] = eq(variables[1], variables[2]); variables[3] = variables[1]/eq(variables[2], variables[2]); diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index 77cb429b1..ecc8522e2 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -9,6 +9,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index d4a72bf60..c05a4023d 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -403,7 +403,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[0] = variables[1] == variables[2]; variables[3] = variables[1]/(variables[2] == variables[2]); diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 0f769b4cb..ef3a093e6 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 19e8c128f..f6b71d310 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -403,7 +403,7 @@ def initialise_variables(states, rates, constants): states[0] = 0.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[0] = eq_func(variables[1], variables[2]) variables[3] = variables[1]/eq_func(variables[2], variables[2]) variables[4] = neq_func(variables[1], variables[2]) diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index 18d0685f7..b4c4b8088 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -142,7 +142,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[0] = variables[1] == variables[2]; variables[3] = variables[1]/(variables[2] == variables[2]); diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 7afb5ad30..8b75532bd 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -403,7 +403,7 @@ def initialise_variables(states, rates, constants): states[0] = 0.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[0] = eq_func(variables[1], variables[2]) variables[3] = variables[1]/eq_func(variables[2], variables[2]) variables[4] = neq_func(variables[1], variables[2]) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index e7a8391fe..26a2df478 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -38,7 +38,7 @@ void initialiseVariables(double *constants) variables[1] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[0] = variables[1]; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index fc41e333b..668e81b0b 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -38,7 +38,7 @@ void initialiseVariables(double *constants, ExternalVariable externalVariable) variables[1] = externalVariable(variables, 1); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index 9ac640aef..8b56d9b9f 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -33,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 781aad578..84b4b2389 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -33,7 +33,7 @@ def initialise_variables(constants, external_variable): variables[1] = external_variable(variables, 1) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index efdd8c3c9..8b9a1fb66 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -30,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index 850fd76c9..fdff9ef0f 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -32,7 +32,7 @@ def initialise_variables(constants): variables[1] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[0] = variables[1] diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index 67d092981..47f5f5248 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -38,7 +38,7 @@ void initialiseVariables(double *constants) variables[1] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[0] = variables[1]; } diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index efdd8c3c9..8b9a1fb66 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -30,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index 94f2dd4a9..ce0f5b10f 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -32,7 +32,7 @@ def initialise_variables(constants): variables[1] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[0] = variables[1] diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index 14e40ccee..7c468c0fc 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -37,7 +37,7 @@ void initialiseVariables(double *constants) variables[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index 1f4d1dcf9..d26413c67 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -30,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index f51bc9ecb..2a902ccf9 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -31,7 +31,7 @@ def initialise_variables(constants): variables[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index dd7546549..29028861f 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -57,7 +57,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index 7b9fab8b6..1eeee2f1e 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 7cff7aaaa..686f0c537 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -46,7 +46,7 @@ def initialise_variables(states, rates, constants): states[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 999d76aa5..7e62bf29a 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -57,7 +57,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index 94a64dfa8..ca79cc5f2 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 0e55e6b5b..46f658054 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -46,7 +46,7 @@ def initialise_variables(states, rates, constants): states[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 3074a08bb..9e4c71ae5 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -57,7 +57,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index 9c395a3d4..d2a3025e3 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 50cfc4e9f..fb9970426 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -46,7 +46,7 @@ def initialise_variables(states, rates, constants): states[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 6a004da95..5f011b73d 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -57,7 +57,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index 50c681f14..cfae2b1d2 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 353cea9ff..ac01ae32c 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -46,7 +46,7 @@ def initialise_variables(states, rates, constants): states[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 7b9e360fc..9913feba2 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -71,7 +71,7 @@ void initialiseVariables(double *constants) variables[2] = 7.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index eda59a04a..f23b5c473 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -43,7 +43,7 @@ void initialiseVariables(double *constants, ExternalVariable externalVariable) variables[3] = externalVariable(variables, 3); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index 9ac640aef..8b56d9b9f 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -33,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 44d1589f0..5b0862177 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -38,7 +38,7 @@ def initialise_variables(constants, external_variable): variables[3] = external_variable(variables, 3) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index efdd8c3c9..8b9a1fb66 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -30,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 98a491a2c..6260fef2e 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -58,7 +58,7 @@ def initialise_variables(constants): variables[2] = 7.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index c2c0ceb69..bf5e76015 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -77,7 +77,7 @@ void initialiseVariables(double *constants) variables[2] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index 7850afa8d..69ce3f676 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -30,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c index 83641270b..de17ebdf8 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c @@ -74,7 +74,7 @@ void initialiseVariables(double *constants, ExternalVariable externalVariable) variables[0] = externalVariable(variables, 0); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h index ffc06e13b..f8cc4af0b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h @@ -33,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py index c0ea0719e..e1ab39418 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py @@ -62,7 +62,7 @@ def initialise_variables(constants, external_variable): variables[0] = external_variable(variables, 0) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 0444e0091..07cdcee4a 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -64,7 +64,7 @@ def initialise_variables(constants): variables[2] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index 38b9632cd..d21c2ed3c 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -41,7 +41,7 @@ void initialiseVariables(double *constants, ExternalVariable externalVariable) variables[2] = externalVariable(variables, 2); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index ffc06e13b..f8cc4af0b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -33,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index c9f380a65..25bd38c60 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -36,7 +36,7 @@ def initialise_variables(constants, external_variable): variables[2] = external_variable(variables, 2) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c index 93170385b..06059cabc 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c @@ -111,7 +111,7 @@ void initialiseVariables(double *constants, ExternalVariable externalVariable) variables[2] = externalVariable(variables, 2); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h index ffc06e13b..f8cc4af0b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h @@ -33,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py index 0c5fbd0d1..ecaa9b697 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py @@ -93,7 +93,7 @@ def initialise_variables(constants, external_variable): variables[2] = external_variable(variables, 2) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index 7988fd4d9..06fecfbf6 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -77,7 +77,7 @@ void initialiseVariables(double *constants) variables[5] = 5.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[3] = 3.0*variables[4]+variables[5]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index 7850afa8d..69ce3f676 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -30,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 732e69482..41286d715 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -64,7 +64,7 @@ def initialise_variables(constants): variables[5] = 5.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[3] = 3.0*variables[4]+variables[5] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index 1f97af5bd..c964d754d 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -77,7 +77,7 @@ void initialiseVariables(double *constants) variables[4] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[0] = 3.0*variables[1]+variables[2]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index 7850afa8d..69ce3f676 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -30,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index eb228d40b..e89d43847 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -64,7 +64,7 @@ def initialise_variables(constants): variables[4] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[0] = 3.0*variables[1]+variables[2] diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index b587e3aaa..8a4752156 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -38,7 +38,7 @@ void initialiseVariables(double *constants) variables[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[1] = variables[0]; } diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index 1f4d1dcf9..d26413c67 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -30,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 40a75154a..7586911e1 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -32,7 +32,7 @@ def initialise_variables(constants): variables[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[1] = variables[0] diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index eb98bbb19..39360db84 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -41,7 +41,7 @@ void initialiseVariables(double *constants) variables[2] = 0.0011; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[0] = 1000.0*3.14*variables[2]*variables[2]*variables[1]; variables[3] = 0.02*variables[0]; diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index c9196c88c..4342b4cbe 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -41,7 +41,7 @@ void initialiseVariables(double *constants, ExternalVariable externalVariable) variables[2] = externalVariable(variables, 2); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 4ff6fcadf..6974bd646 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -33,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index a186a0405..3cd1ff5b1 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -36,7 +36,7 @@ def initialise_variables(constants, external_variable): variables[2] = external_variable(variables, 2) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index 2a61e0d91..d291cbc39 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -30,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index eeb43ec56..0db8de32e 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -35,7 +35,7 @@ def initialise_variables(constants): variables[2] = 0.0011 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[0] = 1000.0*3.14*variables[2]*variables[2]*variables[1] variables[3] = 0.02*variables[0] diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 95661b3c6..19a0356dc 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -58,7 +58,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[1] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index 00bb5bd45..91a2bbdb9 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 70c4e2d23..068ed49c6 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -47,7 +47,7 @@ def initialise_variables(states, rates, constants): states[1] = 0.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index 671757fcc..23470a883 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -48,7 +48,7 @@ def initialise_variables(constants): variables[9] = 2902500.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[0] = variables[1]*(variables[2]*variables[3]-variables[4]*variables[5])/(variables[6]*variables[5]+variables[9]*variables[3]+variables[8]*variables[5]*variables[3]+variables[7]) diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index 7b504d866..1dcda0f17 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = variables[0]; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index 8c3626ccd..e95d12eb1 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 3e187a330..3a44c0f6a 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[0] = variables[0] -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 263e235ef..6f1761c46 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -39,7 +39,7 @@ void initialiseVariables(double *constants) variables[0] = 123.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[1] = variables[0]+variables[0]; variables[2] = 0.001*variables[0]+0.001*variables[0]; diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index c00e1f999..435deb74f 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -30,5 +30,5 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index 0225aaf9a..fb5207527 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -33,7 +33,7 @@ def initialise_variables(constants): variables[0] = 123.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[1] = variables[0]+variables[0] variables[2] = 0.001*variables[0]+0.001*variables[0] diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 34036c90a..a9c2fae82 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 123.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index 8c3626ccd..e95d12eb1 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 758d11eb0..c709d5635 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[0] = 123.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 1237bfea4..047b6b6b0 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 123.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index 8c3626ccd..e95d12eb1 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index 5587cbfc4..429d096f1 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[0] = 123.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index 9a27a9d83..07c05c52b 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[1] = 0.001*789.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index dd033a99a..bd4dd923e 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index 1f6f1d4ba..e9a042ad1 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[1] = 0.001*789.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index 7b0c4b31f..c3fadb370 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -60,7 +60,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[1] = 0.001*variables[1]; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 973e179a4..fc9911e7e 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index f036cd72f..8b55cd099 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -49,7 +49,7 @@ def initialise_variables(states, rates, constants): states[1] = 0.001*variables[1] -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index f283bf9e3..b2c6f6c84 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[1] = 5.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index a4444473c..3f1fb63fd 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index 01562a7bf..e731c2063 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[1] = 5.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index 523518350..7a603b2d4 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -58,7 +58,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[2] = 11.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index b79936bf9..123e68564 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index cdc67162d..d0234d704 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -47,7 +47,7 @@ def initialise_variables(states, rates, constants): states[2] = 11.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 35ff65347..b740b2172 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -131,7 +131,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[1] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 3b1c8ced6..2bcb43579 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 463eee85f..625f4fc24 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -107,7 +107,7 @@ def initialise_variables(states, rates, constants): states[1] = 0.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index c9fc847af..438e96138 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index ebcf19ae6..676c75fec 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index f8022992a..93fe0440b 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[0] = 0.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index b9184e392..041796f93 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -426,7 +426,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[32] = 0.00277; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[3] = variables[119]*variables[120]/variables[17]; variables[6] = variables[3]*log(variables[7]/variables[8]); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 812d0c653..e94e9dec0 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 654449425..c32559549 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -435,7 +435,7 @@ def initialise_variables(states, rates, constants): states[32] = 0.00277 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[3] = variables[119]*variables[120]/variables[17] variables[6] = variables[3]*log(variables[7]/variables[8]) variables[20] = 1.2 if gt_func(variables[1], 0.0) else 1.0 diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 27fc1673a..19eb9ce0b 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -377,7 +377,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[14] = 0.03889291759; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[0] = (variables[2] == 0.0)?1.07*(3.0*variables[1]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295))):(variables[2] == 1.0)?variables[3]*variables[1]/(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295)):1.07*29.0*variables[1]/(30.0*(1.0+0.7745*exp(-(29.0*variables[1]-24.5)/1.95))); variables[4] = variables[5]+variables[0]*(variables[6]-variables[5]); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index d709dca8d..2715ae2d9 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 180b55d8b..2244f1dc9 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -374,7 +374,7 @@ def initialise_variables(states, rates, constants): states[14] = 0.03889291759 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[0] = 1.07*(3.0*variables[1]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295))) if eq_func(variables[2], 0.0) else variables[3]*variables[1]/(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295)) if eq_func(variables[2], 1.0) else 1.07*29.0*variables[1]/(30.0*(1.0+0.7745*exp(-(29.0*variables[1]-24.5)/1.95))) variables[4] = variables[5]+variables[0]*(variables[6]-variables[5]) variables[25] = variables[26]+variables[0]*(variables[27]-variables[26]) if eq_func(variables[2], 0.0) else variables[30]+variables[0]*(variables[31]-variables[30]) if eq_func(variables[2], 1.0) else variables[28]+variables[0]*(variables[29]-variables[28]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index c6af41ab9..fcdfb2971 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -84,7 +84,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons variables[0] = externalVariable(voi, states, rates, variables, 0); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index d621ba0e6..3435c028a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -39,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index f8a6f44c9..c067ca185 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -86,7 +86,7 @@ def initialise_variables(voi, states, rates, constants, external_variable): variables[0] = external_variable(voi, states, rates, variables, 0) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index df2a57cad..4b94c1415 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -83,7 +83,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[3] = 0.325; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index cb6482372..68d2fa006 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -84,7 +84,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons variables[6] = externalVariable(voi, states, rates, variables, 6); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[8] = variables[5]-115.0; variables[14] = variables[5]+12.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index d621ba0e6..3435c028a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -39,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 03186b165..f903b7fc6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -86,7 +86,7 @@ def initialise_variables(voi, states, rates, constants, external_variable): variables[6] = external_variable(voi, states, rates, variables, 6) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index b87f3589f..14a7b75c4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -83,7 +83,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons variables[4] = externalVariable(voi, states, rates, variables, 4); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index d621ba0e6..3435c028a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -39,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 47b39189c..5286f429d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -85,7 +85,7 @@ def initialise_variables(voi, states, rates, constants, external_variable): variables[4] = external_variable(voi, states, rates, variables, 4) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index eec3389de..ed19fae66 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -518,7 +518,7 @@ void initialiseVariables(double *states, double *rates, double *constants) rates[3] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index 1090a6d03..2379ada7d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 110c926fb..a0fd9eb41 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -461,7 +461,7 @@ def initialise_variables(states, rates, constants): rates[3] = 0.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 3abf7d45a..dd14ced27 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -85,7 +85,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons variables[0] = externalVariable(voi, states, rates, variables, 0); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index d621ba0e6..3435c028a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -39,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 2ca6db189..8de578a33 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -87,7 +87,7 @@ def initialise_variables(voi, states, rates, constants, external_variable): variables[0] = external_variable(voi, states, rates, variables, 0) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 13087c293..a28677e4a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -84,7 +84,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons variables[5] = externalVariable(voi, states, rates, variables, 5); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index d621ba0e6..3435c028a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -39,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 2b2d655ac..bf9243f14 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -86,7 +86,7 @@ def initialise_variables(voi, states, rates, constants, external_variable): variables[5] = external_variable(voi, states, rates, variables, 5) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 93afb3d88..ab3a49ebb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -83,7 +83,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons variables[4] = externalVariable(voi, states, rates, variables, 4); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index d621ba0e6..3435c028a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -39,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index c47a5f3ed..bab665d5c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -85,7 +85,7 @@ def initialise_variables(voi, states, rates, constants, external_variable): variables[4] = external_variable(voi, states, rates, variables, 4) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 47ff51ec8..e23e1ca94 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -83,7 +83,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons variables[11] = externalVariable(voi, states, rates, variables, 11); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[7] = variables[6]-10.613; variables[9] = variables[6]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index d621ba0e6..3435c028a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -39,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 72b212b89..630415b7f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -85,7 +85,7 @@ def initialise_variables(voi, states, rates, constants, external_variable): variables[11] = external_variable(voi, states, rates, variables, 11) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[7] = variables[6]-10.613 variables[9] = variables[6]-115.0 variables[16] = variables[6]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index f936897d5..25cd348f1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -85,7 +85,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons variables[4] = externalVariable(voi, states, rates, variables, 4); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[7] = variables[6]-10.613; variables[9] = variables[6]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index d621ba0e6..3435c028a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -39,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 6b77efdbc..c26899b7b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -87,7 +87,7 @@ def initialise_variables(voi, states, rates, constants, external_variable): variables[4] = external_variable(voi, states, rates, variables, 4) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[7] = variables[6]-10.613 variables[9] = variables[6]-115.0 variables[15] = variables[6]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index 1090a6d03..2379ada7d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 6c0ce45df..b673cc050 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -84,7 +84,7 @@ def initialise_variables(states, rates, constants): states[3] = 0.325 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[14] = variables[5]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index ed301760a..d9c4329a9 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -83,7 +83,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons variables[10] = externalVariable(voi, states, rates, variables, 10); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { variables[6] = variables[5]-10.613; variables[8] = variables[5]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index d621ba0e6..3435c028a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -39,6 +39,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index e110f1e76..12843733b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -85,7 +85,7 @@ def initialise_variables(voi, states, rates, constants, external_variable): variables[10] = external_variable(voi, states, rates, variables, 10) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): variables[6] = variables[5]-10.613 variables[8] = variables[5]-115.0 variables[15] = variables[5]+12.0 diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 1029459d2..7f27f8e50 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -82,7 +82,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[3] = 0.01; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index 10555c803..a4c365da2 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 1d18b097a..59f41a51e 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -71,7 +71,7 @@ def initialise_variables(states, rates, constants): states[3] = 0.01 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 621132fc1..481cfdefb 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index a4444473c..3f1fb63fd 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 906bdb3f8..477fed9dc 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 48b06bdb4..8c739e6a7 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index 94a64dfa8..ca79cc5f2 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 1ddea11e3..89a6e82dc 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index 8f42444b8..e6f4a2f11 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index a4444473c..3f1fb63fd 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 2d88bb4b2..7b30f6079 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index 7a5d40207..0b197f7ec 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index 94a64dfa8..ca79cc5f2 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 78fbcf40b..ef811ed30 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index a6d0ec5dc..800b77cfa 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -54,7 +54,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index a4444473c..3f1fb63fd 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index 206392ff3..d1a6f8b8d 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -43,7 +43,7 @@ def initialise_variables(states, rates, constants): states[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 2c479d28d..206912326 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -54,7 +54,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index 94a64dfa8..ca79cc5f2 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index ee87c9c26..6fe4f8a16 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -43,7 +43,7 @@ def initialise_variables(states, rates, constants): states[0] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 5a14fd1ca..9e73023fa 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -58,7 +58,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[1] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index 1653e2e60..cc74aaa0b 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 6e3ba6e67..4bac6fe0c 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -47,7 +47,7 @@ def initialise_variables(states, rates, constants): states[1] = 0.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 1aedd5274..907009cd7 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -58,7 +58,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[1] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index b26a181c2..f0d48d38d 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 9f48dedb9..68fce403b 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -47,7 +47,7 @@ def initialise_variables(states, rates, constants): states[1] = 0.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 0ecc275fc..c53a5bce7 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -58,7 +58,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[1] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index 9ef0b6b75..0b0953abe 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 3b68bcdfd..0d631115b 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -47,7 +47,7 @@ def initialise_variables(states, rates, constants): states[1] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index 90dde15f7..ed4e72be1 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[1] = 1.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index a4444473c..3f1fb63fd 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index aaaa0e947..29380da06 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[1] = 1.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index d0edf14b0..6e6df43ac 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -99,7 +99,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[1] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index 9e43acde3..bca2cef3a 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 147a5f9f1..5094b58a6 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -78,7 +78,7 @@ def initialise_variables(states, rates, constants): states[1] = 0.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 8ef049b2a..7c916a7de 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -65,7 +65,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[2] = 0.0; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index 9e43acde3..bca2cef3a 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 16be8a4e3..e5ed01a6c 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -54,7 +54,7 @@ def initialise_variables(states, rates, constants): states[2] = 0.0 -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index e81c50d4d..e2c69b509 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -71,7 +71,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = variables[1]; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index d1e57debe..93c965f33 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index d4551dbb9..d39e9cfac 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -64,7 +64,7 @@ def initialise_variables(states, rates, constants): states[0] = variables[1] -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index b31c10168..70c1c8775 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -54,7 +54,7 @@ void initialiseVariables(double *constants, ExternalVariable externalVariable) variables[9] = externalVariable(variables, 9); } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 34f0b0874..774d63753 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -33,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); void initialiseVariables(double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index b945a7642..1440ec154 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -49,7 +49,7 @@ def initialise_variables(constants, external_variable): variables[9] = external_variable(variables, 9) -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 1dc483fff..c8282db08 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -56,7 +56,7 @@ void initialiseVariables(double *states, double *rates, double *constants) states[0] = variables[0]; } -void computeComputedConstants(double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants) { } diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index c138b0f36..340f578dd 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -36,6 +36,6 @@ double * createVariablesArray(); void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); -void computeComputedConstants(double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 3982c84aa..73f1eba8c 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -45,7 +45,7 @@ def initialise_variables(states, rates, constants): states[0] = variables[0] -def compute_computed_constants(computed_constants): +def compute_computed_constants(constants, computed_constants): pass From 5287d5b9221d7cb5ba82d806ba2c18e344800424 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 7 Aug 2024 17:15:38 +0200 Subject: [PATCH 07/74] Generator: use computed_constants and not computedConstants in Python. --- src/generatorprofile.cpp | 12 ++++++------ src/generatorprofilesha1values.h | 2 +- .../coverage/generator/model.modified.profile.py | 4 ++-- tests/resources/coverage/generator/model.py | 4 ++-- .../model.external.py | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.py | 2 +- .../algebraic_eqn_const_var_on_rhs/model.py | 2 +- .../generator/algebraic_eqn_constant_on_rhs/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 4 ++-- .../model.py | 4 ++-- .../algebraic_eqn_state_var_on_rhs/model.py | 4 ++-- .../model.py | 4 ++-- .../model.external.py | 2 +- .../model.py | 2 +- .../model.one.external.py | 2 +- .../model.py | 2 +- .../model.three.externals.py | 2 +- .../model.two.externals.py | 2 +- .../model.not.ordered.py | 2 +- .../model.ordered.py | 2 +- .../generator/algebraic_unknown_var_on_rhs/model.py | 2 +- .../generator/cell_geometry_model/model.external.py | 2 +- .../resources/generator/cell_geometry_model/model.py | 2 +- .../cellml_mappings_and_encapsulations/model.py | 4 ++-- .../resources/generator/cellml_slc_example/model.py | 2 +- .../cellml_state_initialised_using_variable/model.py | 4 ++-- .../generator/cellml_unit_scaling_constant/model.py | 2 +- .../generator/cellml_unit_scaling_rate/model.py | 4 ++-- .../generator/cellml_unit_scaling_state/model.py | 4 ++-- .../model.py | 4 ++-- .../model.py | 4 ++-- .../cellml_unit_scaling_voi_direct/model.py | 4 ++-- .../cellml_unit_scaling_voi_indirect/model.py | 4 ++-- .../generator/dae_cellml_1_1_model/model.py | 4 ++-- tests/resources/generator/dependent_eqns/model.py | 4 ++-- .../model.py | 4 ++-- .../model.py | 4 ++-- .../model.algebraic.py | 4 ++-- .../model.computed.constant.py | 4 ++-- .../model.constant.py | 4 ++-- .../model.dae.py | 4 ++-- .../model.dependent.algebraic.py | 4 ++-- .../model.dependent.computed.constant.py | 4 ++-- .../model.dependent.constant.py | 4 ++-- .../model.dependent.state.py | 4 ++-- .../model.external.py | 4 ++-- .../hodgkin_huxley_squid_axon_model_1952/model.py | 4 ++-- .../model.state.py | 4 ++-- tests/resources/generator/noble_model_1962/model.py | 4 ++-- .../generator/ode_computed_var_on_rhs/model.py | 4 ++-- .../ode_computed_var_on_rhs_one_component/model.py | 4 ++-- .../generator/ode_const_var_on_rhs/model.py | 4 ++-- .../ode_const_var_on_rhs_one_component/model.py | 4 ++-- .../resources/generator/ode_constant_on_rhs/model.py | 4 ++-- .../ode_constant_on_rhs_one_component/model.py | 4 ++-- .../generator/ode_multiple_dependent_odes/model.py | 4 ++-- .../model.py | 4 ++-- .../ode_multiple_odes_with_same_name/model.py | 4 ++-- .../generator/ode_unknown_var_on_rhs/model.py | 4 ++-- .../generator/robertson_model_1966/model.dae.py | 4 ++-- .../generator/robertson_model_1966/model.ode.py | 4 ++-- .../resources/generator/sine_model_imports/model.py | 4 ++-- .../unknown_variable_as_external_variable/model.py | 2 +- .../variable_initialised_using_a_constant/model.py | 4 ++-- 64 files changed, 113 insertions(+), 113 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 0c17c44b8..f80ad4d12 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -1097,32 +1097,32 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceComputeRatesMethodWoevString = ""; mImplementationComputeRatesMethodWoevString = "\n" - "def compute_rates(voi, states, rates, constants, computedConstants, algebraic):\n" + "def compute_rates(voi, states, rates, constants, computed_constants, algebraic):\n" "[CODE]"; mInterfaceComputeRatesMethodWevString = ""; mImplementationComputeRatesMethodWevString = "\n" - "def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable):\n" + "def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable):\n" "[CODE]"; mInterfaceComputeVariablesMethodFamWoevString = ""; mImplementationComputeVariablesMethodFamWoevString = "\n" - "def compute_variables(constants, computedConstants, algebraic):\n" + "def compute_variables(constants, computed_constants, algebraic):\n" "[CODE]"; mInterfaceComputeVariablesMethodFamWevString = ""; mImplementationComputeVariablesMethodFamWevString = "\n" - "def compute_variables(constants, computedConstants, algebraic, external_variable):\n" + "def compute_variables(constants, computed_constants, algebraic, external_variable):\n" "[CODE]"; mInterfaceComputeVariablesMethodFdmWoevString = ""; mImplementationComputeVariablesMethodFdmWoevString = "\n" - "def compute_variables(voi, states, rates, constants, computedConstants, algebraic):\n" + "def compute_variables(voi, states, rates, constants, computed_constants, algebraic):\n" "[CODE]"; mInterfaceComputeVariablesMethodFdmWevString = ""; mImplementationComputeVariablesMethodFdmWevString = "\n" - "def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable):\n" + "def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable):\n" "[CODE]"; mEmptyMethodString = "pass\n"; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index ba936cc96..37baac880 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -25,6 +25,6 @@ namespace libcellml { * See docs/dev_utilities.rst for further information. */ static const char C_GENERATOR_PROFILE_SHA1[] = "2e1a7d8b5995845aceceeb06e8f084f9e11fa13d"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "c7d3866a8238ce15df79bf48d83b95c0650de2b4"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "c9f2a238d3334dcca065f2f8f3e1bf3e875e52df"; } // namespace libcellml diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index f6b71d310..8cfd548b6 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -594,9 +594,9 @@ def compute_computed_constants(constants, computed_constants): variables[204] = -and_func(variables[1], variables[2])+-(variables[2] if gt_func(variables[6], variables[18]) else nan) -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, variables) diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 8b75532bd..6c180abe6 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -594,9 +594,9 @@ def compute_computed_constants(constants, computed_constants): variables[204] = -and_func(variables[1], variables[2])+-(variables[2] if gt_func(variables[6], variables[18]) else nan) -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, variables) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 84b4b2389..2c84fc24d 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -37,6 +37,6 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computedConstants, algebraic, external_variable): +def compute_variables(constants, computed_constants, algebraic, external_variable): variables[1] = external_variable(variables, 1) variables[0] = variables[1] diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index fdff9ef0f..924cb661f 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -36,5 +36,5 @@ def compute_computed_constants(constants, computed_constants): variables[0] = variables[1] -def compute_variables(constants, computedConstants, algebraic): +def compute_variables(constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index ce0f5b10f..d0506c02e 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -36,5 +36,5 @@ def compute_computed_constants(constants, computed_constants): variables[0] = variables[1] -def compute_variables(constants, computedConstants, algebraic): +def compute_variables(constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index 2a902ccf9..2dd09c5f7 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -35,5 +35,5 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computedConstants, algebraic): +def compute_variables(constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 686f0c537..e1f727c2e 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -50,9 +50,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[1] = rates[0] diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 46f658054..ecf0e2c0e 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -50,9 +50,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[1] = rates[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index fb9970426..5fbae38c7 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -50,9 +50,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[1] = 2.0*states[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index ac01ae32c..7476abdcb 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -50,9 +50,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[1] = 2.0*states[0] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 5b0862177..3a560ffca 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -42,5 +42,5 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computedConstants, algebraic, external_variable): +def compute_variables(constants, computed_constants, algebraic, external_variable): variables[3] = external_variable(variables, 3) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 6260fef2e..3c1f6c177 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -62,5 +62,5 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computedConstants, algebraic): +def compute_variables(constants, computed_constants, algebraic): find_root_0(variables) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py index e1ab39418..e7930ae9d 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py @@ -66,6 +66,6 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computedConstants, algebraic, external_variable): +def compute_variables(constants, computed_constants, algebraic, external_variable): variables[0] = external_variable(variables, 0) find_root_0(variables) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 07cdcee4a..a5c2fd084 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -68,5 +68,5 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computedConstants, algebraic): +def compute_variables(constants, computed_constants, algebraic): find_root_0(variables) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index 25bd38c60..dc4b5ea80 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -40,7 +40,7 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computedConstants, algebraic, external_variable): +def compute_variables(constants, computed_constants, algebraic, external_variable): variables[0] = external_variable(variables, 0) variables[1] = external_variable(variables, 1) variables[2] = external_variable(variables, 2) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py index ecaa9b697..78b0c39b3 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py @@ -97,7 +97,7 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computedConstants, algebraic, external_variable): +def compute_variables(constants, computed_constants, algebraic, external_variable): variables[0] = external_variable(variables, 0) variables[2] = external_variable(variables, 2) find_root_0(variables) diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 41286d715..09d7f087b 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -68,6 +68,6 @@ def compute_computed_constants(constants, computed_constants): variables[3] = 3.0*variables[4]+variables[5] -def compute_variables(constants, computedConstants, algebraic): +def compute_variables(constants, computed_constants, algebraic): find_root_0(variables) variables[0] = variables[1]+variables[2] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index e89d43847..79c59418a 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -68,6 +68,6 @@ def compute_computed_constants(constants, computed_constants): variables[0] = 3.0*variables[1]+variables[2] -def compute_variables(constants, computedConstants, algebraic): +def compute_variables(constants, computed_constants, algebraic): find_root_0(variables) variables[5] = variables[4]+variables[3] diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 7586911e1..8dbebec15 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -36,5 +36,5 @@ def compute_computed_constants(constants, computed_constants): variables[1] = variables[0] -def compute_variables(constants, computedConstants, algebraic): +def compute_variables(constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 3cd1ff5b1..ddad520d3 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -40,7 +40,7 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computedConstants, algebraic, external_variable): +def compute_variables(constants, computed_constants, algebraic, external_variable): variables[1] = external_variable(variables, 1) variables[2] = external_variable(variables, 2) variables[0] = 1000.0*3.14*variables[2]*variables[2]*variables[1] diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index 0db8de32e..b4f317097 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -40,5 +40,5 @@ def compute_computed_constants(constants, computed_constants): variables[3] = 0.02*variables[0] -def compute_variables(constants, computedConstants, algebraic): +def compute_variables(constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 068ed49c6..b17226251 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -51,11 +51,11 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[1] = -states[0]*1.0 rates[0] = states[1]*1.0 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0) variables[1] = 2.0*states[1] diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index 23470a883..b97fb76d8 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -52,5 +52,5 @@ def compute_computed_constants(constants, computed_constants): variables[0] = variables[1]*(variables[2]*variables[3]-variables[4]*variables[5])/(variables[6]*variables[5]+variables[9]*variables[3]+variables[8]*variables[5]*variables[3]+variables[7]) -def compute_variables(constants, computedConstants, algebraic): +def compute_variables(constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 3a44c0f6a..2acb9513e 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -49,9 +49,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.23 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index fb5207527..fe0dc254f 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -38,5 +38,5 @@ def compute_computed_constants(constants, computed_constants): variables[2] = 0.001*variables[0]+0.001*variables[0] -def compute_variables(constants, computedConstants, algebraic): +def compute_variables(constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index c709d5635..e3ba6287b 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -49,10 +49,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.23 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[0] = 1000.0*rates[0]+1000.0*rates[0] variables[1] = 1000.0*0.001*rates[0]+1000.0*0.001*rates[0] diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index 429d096f1..b690773a8 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -49,10 +49,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.23 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[0] = states[0]+states[0] variables[1] = 0.001*states[0]+0.001*states[0] diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index e9a042ad1..245785261 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -49,10 +49,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.23 rates[1] = 7.89 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 8b55cd099..bd5761c82 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -53,10 +53,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.23 rates[1] = 7.89 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index e731c2063..29f3f445e 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -49,10 +49,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = voi/1.0 rates[1] = 0.001*voi/1.0 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index d0234d704..e9a8f3b73 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -51,11 +51,11 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 5.0 rates[1] = 1000.0*9.0 rates[2] = 0.001*13.0 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 625f4fc24..fd231105c 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -111,7 +111,7 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): variables[2] = states[1]+variables[3] find_root_0(voi, states, rates, variables) rates[0] = variables[0] @@ -121,7 +121,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[1] = variables[6]/variables[9] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[2] = states[1]+variables[3] find_root_0(voi, states, rates, variables) variables[4] = states[0]/variables[7] diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index 93fe0440b..a42b87433 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -49,10 +49,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[1] = 2.0*voi variables[0] = 3.0*variables[1] diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index c32559549..9ef7459aa 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -463,7 +463,7 @@ def compute_computed_constants(constants, computed_constants): variables[213] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*variables[0], 1.6951))+0.025641 -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): variables[5] = states[1] variables[142] = variables[3]*log((variables[4]+0.12*variables[7])/(variables[5]+0.12*variables[8])) variables[121] = variables[123] if and_func(gt_func(voi, variables[124]), lt_func(voi, variables[124]+variables[125])) else variables[126] @@ -595,7 +595,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[32] = (variables[215]-states[32])/variables[216] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[5] = states[1] variables[2] = variables[3]*log(variables[4]/variables[5]) variables[9] = 0.5*variables[3]*log(variables[10]/states[0]) diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 2244f1dc9..911753d70 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -400,7 +400,7 @@ def compute_computed_constants(constants, computed_constants): variables[176] = variables[177]+variables[0]*(variables[178]-variables[177]) if eq_func(variables[2], 0.0) else variables[181]+variables[0]*(variables[182]-variables[181]) if eq_func(variables[2], 1.0) else variables[179]+variables[0]*(variables[180]-variables[179]) -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): variables[9] = variables[62]*pow(variables[56]/(variables[71]+variables[56]), 3.0)*pow(variables[69]/(variables[70]+variables[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) variables[10] = variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.0374*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))) if eq_func(variables[2], 0.0) else variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.03743*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))) variables[14] = variables[176]*states[14]*(states[0]-variables[40]) if neq_func(variables[2], 2.0) else variables[176]*states[14]*(states[0]+102.0) @@ -470,7 +470,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[14] = variables[183]*(1.0-states[14])-variables[184]*states[14] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[13] = variables[25]*(states[0]-variables[32]) variables[11] = variables[33]*(states[0]-variables[40]) variables[12] = variables[41]*(states[0]-variables[48]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index c067ca185..5e1461769 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -92,7 +92,7 @@ def compute_computed_constants(constants, computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[0] = external_variable(voi, states, rates, variables, 0) variables[1] = variables[7]*(states[0]-variables[6]) variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) @@ -109,7 +109,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[0] = external_variable(voi, states, rates, variables, 0) variables[1] = variables[7]*(states[0]-variables[6]) variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index f903b7fc6..e92d16dca 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -91,7 +91,7 @@ def compute_computed_constants(constants, computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[6] = external_variable(voi, states, rates, variables, 6) variables[1] = variables[7]*(states[0]-variables[6]) @@ -109,7 +109,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[6] = external_variable(voi, states, rates, variables, 6) variables[1] = variables[7]*(states[0]-variables[6]) variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 5286f429d..942441414 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -91,7 +91,7 @@ def compute_computed_constants(constants, computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[4] = external_variable(voi, states, rates, variables, 4) variables[1] = variables[7]*(states[0]-variables[6]) @@ -109,7 +109,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[1] = variables[7]*(states[0]-variables[6]) variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index a0fd9eb41..85b8315e5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -465,7 +465,7 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, variables) find_root_2(voi, states, rates, variables) find_root_3(voi, states, rates, variables) @@ -485,7 +485,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): find_root_1(voi, states, rates, variables) -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, variables) find_root_2(voi, states, rates, variables) find_root_3(voi, states, rates, variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 8de578a33..251ac7679 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -93,7 +93,7 @@ def compute_computed_constants(constants, computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[17] = external_variable(voi, states, rates, variables, 17) variables[0] = external_variable(voi, states, rates, variables, 0) variables[1] = variables[7]*(states[0]-variables[6]) @@ -110,7 +110,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[17] = external_variable(voi, states, rates, variables, 17) variables[0] = external_variable(voi, states, rates, variables, 0) variables[1] = variables[7]*(states[0]-variables[6]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index bf9243f14..3c0aa7915 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -90,7 +90,7 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[14] = external_variable(voi, states, rates, variables, 14) variables[5] = external_variable(voi, states, rates, variables, 5) @@ -111,7 +111,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[14] = external_variable(voi, states, rates, variables, 14) variables[5] = external_variable(voi, states, rates, variables, 5) variables[6] = variables[5]-10.613 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index bab665d5c..248c82ab5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -91,7 +91,7 @@ def compute_computed_constants(constants, computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[9] = external_variable(voi, states, rates, variables, 9) variables[4] = external_variable(voi, states, rates, variables, 4) @@ -110,7 +110,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[1] = variables[7]*(states[0]-variables[6]) variables[9] = external_variable(voi, states, rates, variables, 9) variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 630415b7f..adbb263b4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -91,7 +91,7 @@ def compute_computed_constants(constants, computed_constants): variables[16] = variables[6]+12.0 -def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[1] = external_variable(voi, states, rates, variables, 1) variables[14] = 0.07*exp(variables[1]/20.0) variables[15] = 1.0/(exp((variables[1]+30.0)/10.0)+1.0) @@ -101,7 +101,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[1] = variables[18]*(1.0-states[1])-variables[19]*states[1] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[1] = external_variable(voi, states, rates, variables, 1) variables[2] = variables[8]*(variables[1]-variables[7]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index c26899b7b..b280fc68e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -93,7 +93,7 @@ def compute_computed_constants(constants, computed_constants): variables[15] = variables[6]+12.0 -def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[1] = external_variable(voi, states, rates, variables, 1) variables[11] = 0.1*(variables[1]+25.0)/(exp((variables[1]+25.0)/10.0)-1.0) variables[12] = 4.0*exp(variables[1]/18.0) @@ -106,7 +106,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[2] = variables[17]*(1.0-states[2])-variables[18]*states[2] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[1] = external_variable(voi, states, rates, variables, 1) variables[2] = variables[8]*(variables[1]-variables[7]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index b673cc050..621936ae1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -90,7 +90,7 @@ def compute_computed_constants(constants, computed_constants): variables[14] = variables[5]+12.0 -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[1] = variables[7]*(states[0]-variables[6]) variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) @@ -107,7 +107,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[1] = variables[7]*(states[0]-variables[6]) variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 12843733b..72491c454 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -91,7 +91,7 @@ def compute_computed_constants(constants, computed_constants): variables[15] = variables[5]+12.0 -def compute_rates(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 variables[1] = variables[7]*(states[0]-variables[6]) variables[2] = variables[16]*pow(states[2], 4.0)*(states[0]-variables[15]) @@ -106,7 +106,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic, e rates[2] = variables[17]*(1.0-states[2])-variables[18]*states[2] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): variables[1] = variables[7]*(states[0]-variables[6]) variables[10] = external_variable(voi, states, rates, variables, 10) variables[3] = variables[9]*pow(variables[10], 3.0)*states[1]*(states[0]-variables[8]) diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 59f41a51e..11aba05f5 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -75,7 +75,7 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): variables[6] = pow(states[1], 3.0)*states[2]*variables[7] variables[0] = (variables[6]+0.14)*(states[0]-variables[8]) variables[1] = variables[4]*(states[0]-variables[5]) @@ -94,7 +94,7 @@ def compute_rates(voi, states, rates, constants, computedConstants, algebraic): rates[3] = variables[15]*(1.0-states[3])-variables[16]*states[3] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[1] = variables[4]*(states[0]-variables[5]) variables[6] = pow(states[1], 3.0)*states[2]*variables[7] variables[0] = (variables[6]+0.14)*(states[0]-variables[8]) diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 477fed9dc..a9b19e762 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -49,9 +49,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 89a6e82dc..b73399475 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -49,9 +49,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 7b30f6079..ba2af92b3 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -49,9 +49,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index ef811ed30..d5a245651 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -49,9 +49,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = variables[0] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index d1a6f8b8d..d747d3287 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -47,9 +47,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index 6fe4f8a16..beea768e9 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -47,9 +47,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 4bac6fe0c..70c876381 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -51,10 +51,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = states[1]*1.0 rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 68fce403b..a3a521ec2 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -51,10 +51,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = states[1]*1.0 rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 0d631115b..446a164ab 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -51,10 +51,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.0 rates[1] = variables[0] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 29380da06..446d26780 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -49,10 +49,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.0 rates[1] = states[0] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 5094b58a6..24530a58a 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -82,12 +82,12 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, variables) rates[0] = -variables[0]*states[0]+variables[1]*states[1]*variables[2] rates[1] = variables[0]*states[0]-variables[3]*pow(states[1], 2.0)-variables[1]*states[1]*variables[2] -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, variables) variables[4] = 10000.0*states[1] diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index e5ed01a6c..b3c35c945 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -58,11 +58,11 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = -variables[0]*states[0]+variables[1]*states[2]*states[1] rates[2] = variables[0]*states[0]-variables[2]*pow(states[2], 2.0)-variables[1]*states[2]*states[1] rates[1] = variables[2]*pow(states[2], 2.0) -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[3] = 10000.0*states[2] diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index d39e9cfac..563e472da 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -68,11 +68,11 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = cos(voi) -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): variables[0] = sin(voi) variables[9] = voi*variables[4]-0.5 if lt_func(voi, variables[6]) else (3.14159265358979-voi)*variables[4]-0.5 if lt_func(voi, variables[7]) else (voi-3.14159265358979)*variables[4]-0.5 if lt_func(voi, variables[8]) else (variables[5]-voi)*variables[4]-0.5 variables[2] = -variables[9]*variables[9]+variables[3]+variables[9] if lt_func(voi, variables[6]) else -variables[9]*variables[9]+variables[3]+variables[9] if lt_func(voi, variables[7]) else variables[9]*variables[9]-variables[3]-variables[9] if lt_func(voi, variables[8]) else variables[9]*variables[9]-variables[3]-variables[9] diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 1440ec154..de190cb84 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -53,6 +53,6 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computedConstants, algebraic, external_variable): +def compute_variables(constants, computed_constants, algebraic, external_variable): variables[9] = external_variable(variables, 9) variables[0] = variables[1]*(variables[2]*variables[3]-variables[4]*variables[5])/(variables[6]*variables[5]+variables[9]*variables[3]+variables[8]*variables[5]*variables[3]+variables[7]) diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 73f1eba8c..5bfdcb329 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -49,9 +49,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computedConstants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 3.0 -def compute_variables(voi, states, rates, constants, computedConstants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic): pass From 82c104ebcf7b4efedaf5f53233261d3ac838f072 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 7 Aug 2024 17:20:51 +0200 Subject: [PATCH 08/74] Generator profile: bumped the C and Python versions. --- src/generatorprofile.cpp | 4 ++-- src/generatorprofilesha1values.h | 4 ++-- tests/bindings/python/test_generator_profile.py | 2 +- tests/generator/generatorprofile.cpp | 2 +- tests/resources/coverage/generator/model.c | 2 +- tests/resources/coverage/generator/model.modified.profile.c | 2 +- tests/resources/coverage/generator/model.modified.profile.py | 2 +- tests/resources/coverage/generator/model.py | 2 +- .../generator/algebraic_eqn_computed_var_on_rhs/model.c | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.external.c | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.external.py | 2 +- .../generator/algebraic_eqn_computed_var_on_rhs/model.py | 2 +- .../generator/algebraic_eqn_const_var_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_const_var_on_rhs/model.py | 2 +- .../resources/generator/algebraic_eqn_constant_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_constant_on_rhs/model.py | 2 +- .../generator/algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs_one_component/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs_one_component/model.py | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../algebraic_eqn_state_var_on_rhs_one_component/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs_one_component/model.py | 2 +- .../algebraic_eqn_with_one_non_isolated_unknown/model.c | 2 +- .../model.external.c | 2 +- .../model.external.py | 2 +- .../algebraic_eqn_with_one_non_isolated_unknown/model.py | 2 +- .../algebraic_system_with_three_linked_unknowns/model.c | 2 +- .../model.one.external.c | 2 +- .../model.one.external.py | 2 +- .../algebraic_system_with_three_linked_unknowns/model.py | 2 +- .../model.three.externals.c | 2 +- .../model.three.externals.py | 2 +- .../model.two.externals.c | 2 +- .../model.two.externals.py | 2 +- .../model.not.ordered.c | 2 +- .../model.not.ordered.py | 2 +- .../model.ordered.c | 2 +- .../model.ordered.py | 2 +- .../resources/generator/algebraic_unknown_var_on_rhs/model.c | 2 +- .../resources/generator/algebraic_unknown_var_on_rhs/model.py | 2 +- tests/resources/generator/cell_geometry_model/model.c | 2 +- .../resources/generator/cell_geometry_model/model.external.c | 2 +- .../resources/generator/cell_geometry_model/model.external.py | 2 +- tests/resources/generator/cell_geometry_model/model.py | 2 +- .../generator/cellml_mappings_and_encapsulations/model.c | 2 +- .../generator/cellml_mappings_and_encapsulations/model.py | 2 +- tests/resources/generator/cellml_slc_example/model.py | 2 +- .../generator/cellml_state_initialised_using_variable/model.c | 2 +- .../cellml_state_initialised_using_variable/model.py | 2 +- .../resources/generator/cellml_unit_scaling_constant/model.c | 2 +- .../resources/generator/cellml_unit_scaling_constant/model.py | 2 +- tests/resources/generator/cellml_unit_scaling_rate/model.c | 2 +- tests/resources/generator/cellml_unit_scaling_rate/model.py | 2 +- tests/resources/generator/cellml_unit_scaling_state/model.c | 2 +- tests/resources/generator/cellml_unit_scaling_state/model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.c | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.py | 2 +- .../generator/cellml_unit_scaling_voi_indirect/model.c | 2 +- .../generator/cellml_unit_scaling_voi_indirect/model.py | 2 +- tests/resources/generator/dae_cellml_1_1_model/model.c | 2 +- tests/resources/generator/dae_cellml_1_1_model/model.py | 2 +- tests/resources/generator/dependent_eqns/model.c | 2 +- tests/resources/generator/dependent_eqns/model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.algebraic.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.algebraic.py | 2 +- .../generator/hodgkin_huxley_squid_axon_model_1952/model.c | 2 +- .../model.computed.constant.c | 2 +- .../model.computed.constant.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.constant.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.constant.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.py | 2 +- .../model.dependent.algebraic.c | 2 +- .../model.dependent.algebraic.py | 2 +- .../model.dependent.computed.constant.c | 2 +- .../model.dependent.computed.constant.py | 2 +- .../model.dependent.constant.c | 2 +- .../model.dependent.constant.py | 2 +- .../model.dependent.state.c | 2 +- .../model.dependent.state.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.external.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.external.py | 2 +- .../generator/hodgkin_huxley_squid_axon_model_1952/model.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.state.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.state.py | 2 +- tests/resources/generator/noble_model_1962/model.c | 2 +- tests/resources/generator/noble_model_1962/model.py | 2 +- tests/resources/generator/ode_computed_var_on_rhs/model.c | 2 +- tests/resources/generator/ode_computed_var_on_rhs/model.py | 2 +- .../generator/ode_computed_var_on_rhs_one_component/model.c | 2 +- .../generator/ode_computed_var_on_rhs_one_component/model.py | 2 +- tests/resources/generator/ode_const_var_on_rhs/model.c | 2 +- tests/resources/generator/ode_const_var_on_rhs/model.py | 2 +- .../generator/ode_const_var_on_rhs_one_component/model.c | 2 +- .../generator/ode_const_var_on_rhs_one_component/model.py | 2 +- tests/resources/generator/ode_constant_on_rhs/model.c | 2 +- tests/resources/generator/ode_constant_on_rhs/model.py | 2 +- .../generator/ode_constant_on_rhs_one_component/model.c | 2 +- .../generator/ode_constant_on_rhs_one_component/model.py | 2 +- tests/resources/generator/ode_multiple_dependent_odes/model.c | 2 +- .../resources/generator/ode_multiple_dependent_odes/model.py | 2 +- .../ode_multiple_dependent_odes_one_component/model.c | 2 +- .../ode_multiple_dependent_odes_one_component/model.py | 2 +- .../generator/ode_multiple_odes_with_same_name/model.c | 2 +- .../generator/ode_multiple_odes_with_same_name/model.py | 2 +- tests/resources/generator/ode_unknown_var_on_rhs/model.c | 2 +- tests/resources/generator/ode_unknown_var_on_rhs/model.py | 2 +- tests/resources/generator/robertson_model_1966/model.dae.c | 2 +- tests/resources/generator/robertson_model_1966/model.dae.py | 2 +- tests/resources/generator/robertson_model_1966/model.ode.c | 2 +- tests/resources/generator/robertson_model_1966/model.ode.py | 2 +- tests/resources/generator/sine_model_imports/model.c | 2 +- tests/resources/generator/sine_model_imports/model.py | 2 +- .../generator/unknown_variable_as_external_variable/model.c | 2 +- .../generator/unknown_variable_as_external_variable/model.py | 2 +- .../generator/variable_initialised_using_a_constant/model.c | 2 +- .../generator/variable_initialised_using_a_constant/model.py | 2 +- 127 files changed, 129 insertions(+), 129 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index f80ad4d12..3dd23d980 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -503,7 +503,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "#include \n"; mInterfaceVersionString = "extern const char VERSION[];\n"; - mImplementationVersionString = "const char VERSION[] = \"0.5.0\";\n"; + mImplementationVersionString = "const char VERSION[] = \"0.6.0\";\n"; mInterfaceLibcellmlVersionString = "extern const char LIBCELLML_VERSION[];\n"; mImplementationLibcellmlVersionString = "const char LIBCELLML_VERSION[] = \"[LIBCELLML_VERSION]\";\n"; @@ -938,7 +938,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "\n"; mInterfaceVersionString = ""; - mImplementationVersionString = "__version__ = \"0.4.0\"\n"; + mImplementationVersionString = "__version__ = \"0.5.0\"\n"; mInterfaceLibcellmlVersionString = ""; mImplementationLibcellmlVersionString = "LIBCELLML_VERSION = \"[LIBCELLML_VERSION]\"\n"; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 37baac880..0bae464fb 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "2e1a7d8b5995845aceceeb06e8f084f9e11fa13d"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "c9f2a238d3334dcca065f2f8f3e1bf3e875e52df"; +static const char C_GENERATOR_PROFILE_SHA1[] = "060945ab10d8ce4ce063e4b64199f684ec0150a5"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "859d7920e76c1a12345a2d642940163d41d27112"; } // namespace libcellml diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 8749ef922..4eb8a46fa 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -949,7 +949,7 @@ def test_implementation_version_string(self): g = GeneratorProfile() - self.assertEqual('const char VERSION[] = "0.5.0";\n', g.implementationVersionString()) + self.assertEqual('const char VERSION[] = "0.6.0";\n', g.implementationVersionString()) g.setImplementationVersionString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationVersionString()) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index bde173bdc..f690252bc 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -271,7 +271,7 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) generatorProfile->implementationHeaderString()); EXPECT_EQ("extern const char VERSION[];\n", generatorProfile->interfaceVersionString()); - EXPECT_EQ("const char VERSION[] = \"0.5.0\";\n", generatorProfile->implementationVersionString()); + EXPECT_EQ("const char VERSION[] = \"0.6.0\";\n", generatorProfile->implementationVersionString()); EXPECT_EQ("extern const char LIBCELLML_VERSION[];\n", generatorProfile->interfaceLibcellmlVersionString()); EXPECT_EQ("const char LIBCELLML_VERSION[] = \"[LIBCELLML_VERSION]\";\n", generatorProfile->implementationLibcellmlVersionString()); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 9d74d7671..e5bf4ccdf 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index c05a4023d..b86a172b9 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0.post0"; +const char VERSION[] = "0.6.0.post0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 8cfd548b6..a6c7be6c6 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0.post0" +__version__ = "0.5.0.post0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 6c180abe6..1a6049e40 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index 26a2df478..42f15c79b 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 668e81b0b..8cbf6bf05 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 2c84fc24d..2670115d4 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index 924cb661f..24d09dbb1 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index 47f5f5248..dc50dc17e 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index d0506c02e..305a6e7fd 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index 7c468c0fc..5e1791ae7 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index 2dd09c5f7..461c24647 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 29028861f..c37ec4154 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index e1f727c2e..dcdeee9d7 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 7e62bf29a..360d5cdaf 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index ecf0e2c0e..b6ba332de 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 9e4c71ae5..3ad5d8762 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 5fbae38c7..b8d4bcc52 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 5f011b73d..18593d131 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 7476abdcb..6bbd5c64c 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 9913feba2..f8f2240c0 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index f23b5c473..3117d0d81 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 3a560ffca..a2b79b941 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 3c1f6c177..f85863b93 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index bf5e76015..535e4e8e6 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c index de17ebdf8..46aff4ae6 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py index e7930ae9d..bd566aa08 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index a5c2fd084..cd3f4d26a 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index d21c2ed3c..4f5a98709 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index dc4b5ea80..83aafcbbc 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c index 06059cabc..797c82c58 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py index 78b0c39b3..3ce4e8ff0 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index 06fecfbf6..462c28f73 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 09d7f087b..723234a88 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index c964d754d..e8af03001 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 79c59418a..20c8f3155 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index 8a4752156..5224ee214 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 8dbebec15..c4bec2a5c 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index 39360db84..8087a0ebc 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 4342b4cbe..c9c0f76f8 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index ddad520d3..2e565edd4 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index b4f317097..dd282fbf3 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 19a0356dc..af77c8adb 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index b17226251..48ead204d 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index b97fb76d8..e46136ff8 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index 1dcda0f17..fd33a5b30 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 2acb9513e..246d135ba 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 6f1761c46..5ec839f54 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index fe0dc254f..83f5af0c9 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index a9c2fae82..56547ca65 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index e3ba6287b..97589bc34 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 047b6b6b0..fc1ab5e93 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index b690773a8..1c964deb8 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index 07c05c52b..c0db3b3a3 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index 245785261..86e48a995 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index c3fadb370..bafc5259f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index bd5761c82..029b44f7a 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index b2c6f6c84..f0e1d42ba 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index 29f3f445e..e14df017f 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index 7a603b2d4..cd6840c59 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 3; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index e9a8f3b73..ac4a5b309 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 3 diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index b740b2172..c349b48ca 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index fd231105c..793f148fa 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 438e96138..e85abef76 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index a42b87433..a5a26864c 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 041796f93..ee620de9a 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 33; diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 9ef7459aa..9831f67e5 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 33 diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 19eb9ce0b..d2856f1c0 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 15; diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 911753d70..4a43aaffe 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 15 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index fcdfb2971..b7a5b4fd4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 5e1461769..0b83a47b5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 4b94c1415..11925369a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 68d2fa006..122e1223d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index e92d16dca..a68331edb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 14a7b75c4..074683762 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 942441414..ea8e627d8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index ed19fae66..3dd59ed73 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 85b8315e5..b74a9e03c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index dd14ced27..d71fcc410 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 251ac7679..4f026e071 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index a28677e4a..35e65eb5b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 3c0aa7915..fa9198906 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index ab3a49ebb..a5180f902 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 248c82ab5..71f9a4827 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index e23e1ca94..0f7cdf505 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index adbb263b4..16326c27d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 25cd348f1..4deb76e68 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 3; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index b280fc68e..89c02e24c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 621936ae1..a1d5201a6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index d9c4329a9..b042ee21e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 3; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 72491c454..39debf9ca 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 3 diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 7f27f8e50..8edc882e1 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 11aba05f5..878cc8960 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 481cfdefb..741fc1a1e 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index a9b19e762..865bb0a91 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 8c739e6a7..2bc00c84f 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index b73399475..34f7dfbc5 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index e6f4a2f11..65d922d8b 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index ba2af92b3..e2df2355f 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index 0b197f7ec..8ea505b7f 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index d5a245651..939cc09a0 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index 800b77cfa..71e7ea5a8 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index d747d3287..bc525feb5 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 206912326..a37c8889b 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index beea768e9..22311d1da 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 9e73023fa..bab99e785 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 70c876381..50498a2ba 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 907009cd7..c5e7e02a6 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index a3a521ec2..d5b1bf1b9 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index c53a5bce7..967c84456 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 446a164ab..8ac8235fc 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index ed4e72be1..0b29e548b 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 446d26780..2f19ddc26 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 6e6df43ac..1f99605fa 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 24530a58a..02d98e3c7 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 7c916a7de..755412f68 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 3; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index b3c35c945..5fba7eba4 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 3 diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index e2c69b509..29f467ca1 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 563e472da..3319297ff 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 70c1c8775..1d5fac7e8 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index de190cb84..8f2c23fba 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index c8282db08..bbd31e50c 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.5.0"; +const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 5bfdcb329..e6b607b12 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.4.0" +__version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 From 0f8fbf303c4ca35763130c8c9dc1bd40d4eba479 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 8 Aug 2024 10:52:29 +0200 Subject: [PATCH 09/74] Tests: automatically generate the expected file contents. To do it manually is very time consuming while here it gets done automatically. From there, we can quickly confirm, using git, whether the new expected file contents is correct. --- tests/clone/clone.cpp | 2 +- tests/coverage/coverage.cpp | 18 +- tests/generator/generator.cpp | 356 ++++++++++++++-------------- tests/importer/importer.cpp | 6 +- tests/importer/model_flattening.cpp | 6 +- tests/printer/printer.cpp | 2 +- tests/test_utils.cpp | 17 +- tests/test_utils.h | 5 + 8 files changed, 216 insertions(+), 196 deletions(-) diff --git a/tests/clone/clone.cpp b/tests/clone/clone.cpp index f92ecd62f..1b0b7a47b 100644 --- a/tests/clone/clone.cpp +++ b/tests/clone/clone.cpp @@ -503,7 +503,7 @@ TEST(Clone, generateFromClonedModel) generator->setModel(analyser->model()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.c", generator->implementationCode()); libcellml::PrinterPtr p = libcellml::Printer::create(); diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 5805d7803..ab5aac84b 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -666,8 +666,8 @@ TEST(Coverage, generator) generator->setModel(analyserModel); EXPECT_EQ(analyserModel, generator->model()); - EXPECT_EQ(fileContents("coverage/generator/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("coverage/generator/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.c", generator->implementationCode()); auto profile = generator->profile(); @@ -683,8 +683,8 @@ TEST(Coverage, generator) " return res;\n" "}\n"); - EXPECT_EQ(fileContents("coverage/generator/model.modified.profile.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("coverage/generator/model.modified.profile.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.modified.profile.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.modified.profile.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(); @@ -751,7 +751,7 @@ TEST(Coverage, generator) profile->setImplementationComputeVariablesMethodString(true, true, ""); EXPECT_EQ(EMPTY_STRING, generator->interfaceCode()); - EXPECT_EQ(fileContents("coverage/generator/model.out"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.out", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(); @@ -824,20 +824,20 @@ TEST(Coverage, generator) profile->setVariableInfoEntryString(""); - EXPECT_EQ(fileContents("coverage/generator/model.interface.out"), generator->interfaceCode()); - EXPECT_EQ(fileContents("coverage/generator/model.implementation.out"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.interface.out", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.implementation.out", generator->implementationCode()); profile->setProfile(libcellml::GeneratorProfile::Profile::PYTHON); EXPECT_EQ(EMPTY_STRING, generator->interfaceCode()); - EXPECT_EQ(fileContents("coverage/generator/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.py", generator->implementationCode()); profile->setImplementationCreateStatesArrayMethodString("\n" "def create_states_vector():\n" " return [nan]*STATE_COUNT\n"); EXPECT_EQ(EMPTY_STRING, generator->interfaceCode()); - EXPECT_EQ(fileContents("coverage/generator/model.modified.profile.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("coverage/generator/model.modified.profile.py", generator->implementationCode()); // Coverage for the case where mProfile is equal to nullptr in Generator. diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index 2494fa8dc..9bfab3e60 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -58,14 +58,14 @@ TEST(Generator, algebraicEqnComputedVarOnRhs) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/algebraic_eqn_computed_var_on_rhs/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_eqn_computed_var_on_rhs/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_computed_var_on_rhs/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_computed_var_on_rhs/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_eqn_computed_var_on_rhs/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_computed_var_on_rhs/model.py", generator->implementationCode()); } TEST(Generator, algebraicEqnComputedVarOnRhsWithComputedConstantAsExternalVariable) @@ -92,14 +92,14 @@ TEST(Generator, algebraicEqnComputedVarOnRhsWithComputedConstantAsExternalVariab profile->setInterfaceFileNameString("model.external.h"); - EXPECT_EQ(fileContents("generator/algebraic_eqn_computed_var_on_rhs/model.external.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_eqn_computed_var_on_rhs/model.external.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_computed_var_on_rhs/model.external.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_computed_var_on_rhs/model.external.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_eqn_computed_var_on_rhs/model.external.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_computed_var_on_rhs/model.external.py", generator->implementationCode()); } TEST(Generator, algebraicEqnConstVarOnRhs) @@ -120,14 +120,14 @@ TEST(Generator, algebraicEqnConstVarOnRhs) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/algebraic_eqn_const_var_on_rhs/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_eqn_const_var_on_rhs/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_const_var_on_rhs/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_const_var_on_rhs/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_eqn_const_var_on_rhs/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_const_var_on_rhs/model.py", generator->implementationCode()); } TEST(Generator, algebraicEqnConstantOnRhs) @@ -148,14 +148,14 @@ TEST(Generator, algebraicEqnConstantOnRhs) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/algebraic_eqn_constant_on_rhs/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_eqn_constant_on_rhs/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_constant_on_rhs/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_constant_on_rhs/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_eqn_constant_on_rhs/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_constant_on_rhs/model.py", generator->implementationCode()); } TEST(Generator, algebraicEqnDerivativeOnRhs) @@ -176,14 +176,14 @@ TEST(Generator, algebraicEqnDerivativeOnRhs) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/algebraic_eqn_derivative_on_rhs/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_eqn_derivative_on_rhs/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_on_rhs/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_on_rhs/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_eqn_derivative_on_rhs/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_on_rhs/model.py", generator->implementationCode()); } TEST(Generator, algebraicEqnDerivativeOnRhsOneComponent) @@ -204,14 +204,14 @@ TEST(Generator, algebraicEqnDerivativeOnRhsOneComponent) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/algebraic_eqn_derivative_on_rhs_one_component/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_eqn_derivative_on_rhs_one_component/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_on_rhs_one_component/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_on_rhs_one_component/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_eqn_derivative_on_rhs_one_component/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_on_rhs_one_component/model.py", generator->implementationCode()); } TEST(Generator, algebraicEqnStateVarOnRhs) @@ -232,14 +232,14 @@ TEST(Generator, algebraicEqnStateVarOnRhs) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/algebraic_eqn_state_var_on_rhs/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_eqn_state_var_on_rhs/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_eqn_state_var_on_rhs/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs/model.py", generator->implementationCode()); } TEST(Generator, algebraicEqnStateVarOnRhsOneComponent) @@ -260,14 +260,14 @@ TEST(Generator, algebraicEqnStateVarOnRhsOneComponent) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/algebraic_eqn_state_var_on_rhs_one_component/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_eqn_state_var_on_rhs_one_component/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs_one_component/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs_one_component/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_eqn_state_var_on_rhs_one_component/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs_one_component/model.py", generator->implementationCode()); } TEST(Generator, algebraicUnknownVarOnRhs) @@ -288,14 +288,14 @@ TEST(Generator, algebraicUnknownVarOnRhs) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/algebraic_unknown_var_on_rhs/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_unknown_var_on_rhs/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_unknown_var_on_rhs/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_unknown_var_on_rhs/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_unknown_var_on_rhs/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_unknown_var_on_rhs/model.py", generator->implementationCode()); } TEST(Generator, algebraicEqnWithOneNonIsolatedUnknown) @@ -316,14 +316,14 @@ TEST(Generator, algebraicEqnWithOneNonIsolatedUnknown) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/algebraic_eqn_with_one_non_isolated_unknown/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_eqn_with_one_non_isolated_unknown/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_eqn_with_one_non_isolated_unknown/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.py", generator->implementationCode()); } TEST(Generator, algebraicEqnWithOneNonIsolatedUnknownWithExternalVariable) @@ -350,14 +350,14 @@ TEST(Generator, algebraicEqnWithOneNonIsolatedUnknownWithExternalVariable) profile->setInterfaceFileNameString("model.external.h"); - EXPECT_EQ(fileContents("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py", generator->implementationCode()); } TEST(Generator, algebraicSystemWithThreeLinkedUnknowns) @@ -378,14 +378,14 @@ TEST(Generator, algebraicSystemWithThreeLinkedUnknowns) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/algebraic_system_with_three_linked_unknowns/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_system_with_three_linked_unknowns/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_system_with_three_linked_unknowns/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.py", generator->implementationCode()); } TEST(Generator, algebraicSystemWithThreeLinkedUnknownsWithThreeExternalVariables) @@ -414,14 +414,14 @@ TEST(Generator, algebraicSystemWithThreeLinkedUnknownsWithThreeExternalVariables profile->setInterfaceFileNameString("model.three.externals.h"); - EXPECT_EQ(fileContents("generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py", generator->implementationCode()); } TEST(Generator, algebraicSystemWithVariousDependenciesOrdered) @@ -446,14 +446,14 @@ TEST(Generator, algebraicSystemWithVariousDependenciesOrdered) profile->setInterfaceFileNameString("model.ordered.h"); - EXPECT_EQ(fileContents("generator/algebraic_system_with_various_dependencies/model.ordered.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_system_with_various_dependencies/model.ordered.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_various_dependencies/model.ordered.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_various_dependencies/model.ordered.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_system_with_various_dependencies/model.ordered.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_various_dependencies/model.ordered.py", generator->implementationCode()); } TEST(Generator, algebraicSystemWithVariousDependenciesNotOrdered) @@ -478,14 +478,14 @@ TEST(Generator, algebraicSystemWithVariousDependenciesNotOrdered) profile->setInterfaceFileNameString("model.not.ordered.h"); - EXPECT_EQ(fileContents("generator/algebraic_system_with_various_dependencies/model.not.ordered.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/algebraic_system_with_various_dependencies/model.not.ordered.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_various_dependencies/model.not.ordered.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_various_dependencies/model.not.ordered.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/algebraic_system_with_various_dependencies/model.not.ordered.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_various_dependencies/model.not.ordered.py", generator->implementationCode()); } TEST(Generator, odeComputedVarOnRhs) @@ -506,14 +506,14 @@ TEST(Generator, odeComputedVarOnRhs) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/ode_computed_var_on_rhs/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/ode_computed_var_on_rhs/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_computed_var_on_rhs/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_computed_var_on_rhs/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/ode_computed_var_on_rhs/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_computed_var_on_rhs/model.py", generator->implementationCode()); } TEST(Generator, odeComputedVarOnRhsOneComponent) @@ -534,14 +534,14 @@ TEST(Generator, odeComputedVarOnRhsOneComponent) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/ode_computed_var_on_rhs_one_component/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/ode_computed_var_on_rhs_one_component/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_computed_var_on_rhs_one_component/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_computed_var_on_rhs_one_component/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/ode_computed_var_on_rhs_one_component/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_computed_var_on_rhs_one_component/model.py", generator->implementationCode()); } TEST(Generator, odeConstVarOnRhs) @@ -562,14 +562,14 @@ TEST(Generator, odeConstVarOnRhs) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/ode_const_var_on_rhs/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/ode_const_var_on_rhs/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_const_var_on_rhs/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_const_var_on_rhs/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/ode_const_var_on_rhs/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_const_var_on_rhs/model.py", generator->implementationCode()); } TEST(Generator, odeConstVarOnRhsOneComponent) @@ -590,14 +590,14 @@ TEST(Generator, odeConstVarOnRhsOneComponent) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/ode_const_var_on_rhs_one_component/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/ode_const_var_on_rhs_one_component/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_const_var_on_rhs_one_component/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_const_var_on_rhs_one_component/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/ode_const_var_on_rhs_one_component/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_const_var_on_rhs_one_component/model.py", generator->implementationCode()); } TEST(Generator, odeConstantOnRhs) @@ -618,14 +618,14 @@ TEST(Generator, odeConstantOnRhs) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/ode_constant_on_rhs/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/ode_constant_on_rhs/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_constant_on_rhs/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_constant_on_rhs/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/ode_constant_on_rhs/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_constant_on_rhs/model.py", generator->implementationCode()); } TEST(Generator, odeConstantOnRhsOneComponent) @@ -646,14 +646,14 @@ TEST(Generator, odeConstantOnRhsOneComponent) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/ode_constant_on_rhs_one_component/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/ode_constant_on_rhs_one_component/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_constant_on_rhs_one_component/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_constant_on_rhs_one_component/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/ode_constant_on_rhs_one_component/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_constant_on_rhs_one_component/model.py", generator->implementationCode()); } TEST(Generator, odeMultipleDependentOdes) @@ -674,14 +674,14 @@ TEST(Generator, odeMultipleDependentOdes) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/ode_multiple_dependent_odes/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/ode_multiple_dependent_odes/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_multiple_dependent_odes/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_multiple_dependent_odes/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/ode_multiple_dependent_odes/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_multiple_dependent_odes/model.py", generator->implementationCode()); } TEST(Generator, odeMultipleDependentOdesOneComponent) @@ -702,14 +702,14 @@ TEST(Generator, odeMultipleDependentOdesOneComponent) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/ode_multiple_dependent_odes_one_component/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/ode_multiple_dependent_odes_one_component/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_multiple_dependent_odes_one_component/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_multiple_dependent_odes_one_component/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/ode_multiple_dependent_odes_one_component/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_multiple_dependent_odes_one_component/model.py", generator->implementationCode()); } TEST(Generator, odeMultipleOdesWithSameName) @@ -730,14 +730,14 @@ TEST(Generator, odeMultipleOdesWithSameName) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/ode_multiple_odes_with_same_name/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/ode_multiple_odes_with_same_name/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_multiple_odes_with_same_name/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_multiple_odes_with_same_name/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/ode_multiple_odes_with_same_name/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_multiple_odes_with_same_name/model.py", generator->implementationCode()); } TEST(Generator, odeUnknownVarOnRhs) @@ -758,14 +758,14 @@ TEST(Generator, odeUnknownVarOnRhs) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/ode_unknown_var_on_rhs/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/ode_unknown_var_on_rhs/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_unknown_var_on_rhs/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_unknown_var_on_rhs/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/ode_unknown_var_on_rhs/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_unknown_var_on_rhs/model.py", generator->implementationCode()); } TEST(Generator, cellmlMappingsAndEncapsulations) @@ -786,14 +786,14 @@ TEST(Generator, cellmlMappingsAndEncapsulations) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/cellml_mappings_and_encapsulations/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/cellml_mappings_and_encapsulations/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_mappings_and_encapsulations/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_mappings_and_encapsulations/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cellml_mappings_and_encapsulations/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_mappings_and_encapsulations/model.py", generator->implementationCode()); } TEST(Generator, cellmlStateInitialisedUsingVariable) @@ -814,14 +814,14 @@ TEST(Generator, cellmlStateInitialisedUsingVariable) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/cellml_state_initialised_using_variable/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/cellml_state_initialised_using_variable/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_state_initialised_using_variable/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_state_initialised_using_variable/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cellml_state_initialised_using_variable/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_state_initialised_using_variable/model.py", generator->implementationCode()); } TEST(Generator, cellmlUnitScalingVoiIndirect) @@ -842,14 +842,14 @@ TEST(Generator, cellmlUnitScalingVoiIndirect) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_voi_indirect/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_voi_indirect/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_voi_indirect/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_voi_indirect/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_voi_indirect/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_voi_indirect/model.py", generator->implementationCode()); } TEST(Generator, cellmlUnitScalingVoiDirect) @@ -870,14 +870,14 @@ TEST(Generator, cellmlUnitScalingVoiDirect) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_voi_direct/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_voi_direct/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_voi_direct/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_voi_direct/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_voi_direct/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_voi_direct/model.py", generator->implementationCode()); } TEST(Generator, cellmlUnitScalingConstant) @@ -898,14 +898,14 @@ TEST(Generator, cellmlUnitScalingConstant) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_constant/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_constant/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_constant/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_constant/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_constant/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_constant/model.py", generator->implementationCode()); } TEST(Generator, cellmlUnitScalingState) @@ -926,14 +926,14 @@ TEST(Generator, cellmlUnitScalingState) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_state/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_state/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_state/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_state/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_state/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_state/model.py", generator->implementationCode()); } TEST(Generator, cellmlUnitScalingStateInitialisedUsingConstant) @@ -954,14 +954,14 @@ TEST(Generator, cellmlUnitScalingStateInitialisedUsingConstant) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_state_initialised_using_constant/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_state_initialised_using_constant/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_state_initialised_using_constant/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_state_initialised_using_constant/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_state_initialised_using_constant/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_state_initialised_using_constant/model.py", generator->implementationCode()); } TEST(Generator, cellmlUnitScalingStateInitialisedUsingVariable) @@ -982,14 +982,14 @@ TEST(Generator, cellmlUnitScalingStateInitialisedUsingVariable) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_state_initialised_using_variable/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_state_initialised_using_variable/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_state_initialised_using_variable/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_state_initialised_using_variable/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_state_initialised_using_variable/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_state_initialised_using_variable/model.py", generator->implementationCode()); } TEST(Generator, cellmlUnitScalingRate) @@ -1010,14 +1010,14 @@ TEST(Generator, cellmlUnitScalingRate) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_rate/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_rate/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_rate/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_rate/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cellml_unit_scaling_rate/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_unit_scaling_rate/model.py", generator->implementationCode()); } TEST(Generator, dependentEqns) @@ -1038,14 +1038,14 @@ TEST(Generator, dependentEqns) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/dependent_eqns/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/dependent_eqns/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/dependent_eqns/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/dependent_eqns/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/dependent_eqns/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/dependent_eqns/model.py", generator->implementationCode()); } TEST(Generator, cellGeometryModel) @@ -1066,14 +1066,14 @@ TEST(Generator, cellGeometryModel) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/cell_geometry_model/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/cell_geometry_model/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cell_geometry_model/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cell_geometry_model/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cell_geometry_model/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cell_geometry_model/model.py", generator->implementationCode()); } TEST(Generator, cellGeometryModelWithSomeConstantsAsExternalVariables) @@ -1101,14 +1101,14 @@ TEST(Generator, cellGeometryModelWithSomeConstantsAsExternalVariables) profile->setInterfaceFileNameString("model.external.h"); - EXPECT_EQ(fileContents("generator/cell_geometry_model/model.external.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/cell_geometry_model/model.external.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cell_geometry_model/model.external.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cell_geometry_model/model.external.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cell_geometry_model/model.external.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cell_geometry_model/model.external.py", generator->implementationCode()); } TEST(Generator, fabbriFantiniWildersSeveriHumanSanModel2017) @@ -1129,14 +1129,14 @@ TEST(Generator, fabbriFantiniWildersSeveriHumanSanModel2017) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py", generator->implementationCode()); } TEST(Generator, garnyKohlHunterBoyettNobleRabbitSanModel2003) @@ -1157,14 +1157,14 @@ TEST(Generator, garnyKohlHunterBoyettNobleRabbitSanModel2003) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952) @@ -1185,14 +1185,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952UnknownVarsOnRhs) @@ -1213,14 +1213,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952UnknownVarsOnRhs) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952WithStateVariableAsExternalVariable) @@ -1250,14 +1250,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithStateVariableAsExternalVariab profile->setInterfaceFileNameString("model.state.h"); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.state.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.state.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.state.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.state.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.state.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.state.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952WithStateVariablesAsExternalVariablesIncludingOneDependingOnTheOther) @@ -1294,14 +1294,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithStateVariablesAsExternalVaria profile->setInterfaceFileNameString("model.dependent.state.h"); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952WithConstantAsExternalVariable) @@ -1331,14 +1331,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithConstantAsExternalVariable) profile->setInterfaceFileNameString("model.constant.h"); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952WithConstantsAsExternalVariablesIncludingOneDependingOnTheOther) @@ -1374,14 +1374,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithConstantsAsExternalVariablesI profile->setInterfaceFileNameString("model.dependent.constant.h"); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952WithComputedConstantAsExternalVariable) @@ -1411,14 +1411,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithComputedConstantAsExternalVar profile->setInterfaceFileNameString("model.computed.constant.h"); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952WithComputedConstantsAsExternalVariablesIncludingOneDependingOnTheOther) @@ -1454,14 +1454,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithComputedConstantsAsExternalVa profile->setInterfaceFileNameString("model.dependent.computed.constant.h"); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952WithAlgebraicVariableAsExternalVariable) @@ -1491,14 +1491,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithAlgebraicVariableAsExternalVa profile->setInterfaceFileNameString("model.algebraic.h"); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952WithAlgebraicVariablesAsExternalVariablesIncludingOneDependingOnTheOther) @@ -1534,14 +1534,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithAlgebraicVariablesAsExternalV profile->setInterfaceFileNameString("model.dependent.algebraic.h"); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952WithVariousExternalVariables) @@ -1584,14 +1584,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithVariousExternalVariables) profile->setInterfaceFileNameString("model.external.h"); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.external.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.external.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.external.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.external.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.external.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.external.py", generator->implementationCode()); } TEST(Generator, hodgkinHuxleySquidAxonModel1952Nla) @@ -1619,14 +1619,14 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952Nla) profile->setInterfaceFileNameString("model.dae.h"); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py", generator->implementationCode()); } TEST(Generator, nobleModel1962) @@ -1647,14 +1647,14 @@ TEST(Generator, nobleModel1962) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/noble_model_1962/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/noble_model_1962/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/noble_model_1962/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/noble_model_1962/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/noble_model_1962/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/noble_model_1962/model.py", generator->implementationCode()); } TEST(Generator, robertsonOdeModel1966) @@ -1679,14 +1679,14 @@ TEST(Generator, robertsonOdeModel1966) profile->setInterfaceFileNameString("model.ode.h"); - EXPECT_EQ(fileContents("generator/robertson_model_1966/model.ode.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/robertson_model_1966/model.ode.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/robertson_model_1966/model.ode.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/robertson_model_1966/model.ode.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/robertson_model_1966/model.ode.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/robertson_model_1966/model.ode.py", generator->implementationCode()); } TEST(Generator, robertsonDaeModel1966) @@ -1711,14 +1711,14 @@ TEST(Generator, robertsonDaeModel1966) profile->setInterfaceFileNameString("model.dae.h"); - EXPECT_EQ(fileContents("generator/robertson_model_1966/model.dae.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/robertson_model_1966/model.dae.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/robertson_model_1966/model.dae.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/robertson_model_1966/model.dae.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/robertson_model_1966/model.dae.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/robertson_model_1966/model.dae.py", generator->implementationCode()); } TEST(Generator, sineImports) @@ -1747,14 +1747,14 @@ TEST(Generator, sineImports) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/sine_model_imports/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/sine_model_imports/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/sine_model_imports/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/sine_model_imports/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/sine_model_imports/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/sine_model_imports/model.py", generator->implementationCode()); } TEST(Generator, analyserModelScopeTest) @@ -1778,8 +1778,8 @@ TEST(Generator, analyserModelScopeTest) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.c", generator->implementationCode()); } TEST(Generator, daeModel) @@ -1800,14 +1800,14 @@ TEST(Generator, daeModel) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/dae_cellml_1_1_model/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/dae_cellml_1_1_model/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/dae_cellml_1_1_model/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/dae_cellml_1_1_model/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/dae_cellml_1_1_model/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/dae_cellml_1_1_model/model.py", generator->implementationCode()); } TEST(Generator, variableInitialisedUsingAConstant) @@ -1828,14 +1828,14 @@ TEST(Generator, variableInitialisedUsingAConstant) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/variable_initialised_using_a_constant/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/variable_initialised_using_a_constant/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/variable_initialised_using_a_constant/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/variable_initialised_using_a_constant/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/variable_initialised_using_a_constant/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/variable_initialised_using_a_constant/model.py", generator->implementationCode()); } TEST(Generator, modelOutOfScope) @@ -1864,7 +1864,7 @@ TEST(Generator, modelOutOfScope) generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/ode_multiple_dependent_odes/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/ode_multiple_dependent_odes/model.py", generator->implementationCode()); } TEST(Generator, unknownVariableMarkedAsExternalVariable) @@ -1887,14 +1887,14 @@ TEST(Generator, unknownVariableMarkedAsExternalVariable) generator->setModel(analyserModel); - EXPECT_EQ(fileContents("generator/unknown_variable_as_external_variable/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/unknown_variable_as_external_variable/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/unknown_variable_as_external_variable/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/unknown_variable_as_external_variable/model.c", generator->implementationCode()); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/unknown_variable_as_external_variable/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/unknown_variable_as_external_variable/model.py", generator->implementationCode()); } TEST(Generator, modelWithComplexUnitsOutOfScope) @@ -1928,5 +1928,5 @@ TEST(Generator, modelWithComplexUnitsOutOfScope) generator->setProfile(profile); - EXPECT_EQ(fileContents("generator/cellml_slc_example/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_slc_example/model.py", generator->implementationCode()); } diff --git a/tests/importer/importer.cpp b/tests/importer/importer.cpp index 3f959e71a..3ebab5811 100644 --- a/tests/importer/importer.cpp +++ b/tests/importer/importer.cpp @@ -334,9 +334,9 @@ TEST(Importer, accessImportedModelLibrary) auto point = importer->library(resourcePath("importer/diamond_point.cellml")); // Test that the library items are the same as those in the files. - EXPECT_EQ(fileContents("importer/diamond_left.cellml"), printer->printModel(left)); - EXPECT_EQ(fileContents("importer/diamond_right.cellml"), printer->printModel(right)); - EXPECT_EQ(fileContents("importer/diamond_point.cellml"), printer->printModel(point)); + EXPECT_EQ_FILE_CONTENTS("importer/diamond_left.cellml", printer->printModel(left)); + EXPECT_EQ_FILE_CONTENTS("importer/diamond_right.cellml", printer->printModel(right)); + EXPECT_EQ_FILE_CONTENTS("importer/diamond_point.cellml", printer->printModel(point)); } TEST(Importer, multipleModelResolution) diff --git a/tests/importer/model_flattening.cpp b/tests/importer/model_flattening.cpp index 80c218df3..f28e84713 100644 --- a/tests/importer/model_flattening.cpp +++ b/tests/importer/model_flattening.cpp @@ -734,15 +734,15 @@ TEST(ModelFlattening, hodgkinHuxleyDefinedUsingImports) generator->setModel(analyser->model()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.h"), generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.c"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.c", generator->implementationCode()); libcellml::GeneratorProfilePtr profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); EXPECT_EQ("", generator->interfaceCode()); - EXPECT_EQ(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.py"), generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.py", generator->implementationCode()); } TEST(ModelFlattening, importedComponentsWithConnectionsToChildren) diff --git a/tests/printer/printer.cpp b/tests/printer/printer.cpp index a55cf81ce..74692e53d 100644 --- a/tests/printer/printer.cpp +++ b/tests/printer/printer.cpp @@ -312,7 +312,7 @@ TEST(Printer, printModelWithTabs) libcellml::ModelPtr model = parser->parseModel(fileContents("printer/tabulated_model.cellml")); libcellml::PrinterPtr printer = libcellml::Printer::create(); - EXPECT_EQ(fileContents("printer/spaced_model.cellml"), printer->printModel(model)); + EXPECT_EQ_FILE_CONTENTS("printer/spaced_model.cellml", printer->printModel(model)); } TEST(Printer, printModelWithStandardUnitsAdded) diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 8aafe6088..0275c8483 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -216,7 +216,6 @@ std::vector expectedUrls(size_t size, std::string url) } void expectEqualIssues(const std::vector &issues, const libcellml::LoggerPtr &logger) - { EXPECT_EQ(issues.size(), logger->issueCount()); for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { @@ -417,3 +416,19 @@ void compareReset(const libcellml::ResetPtr &r1, const libcellml::ResetPtr &r2) EXPECT_EQ(r1->testValueId(), r2->testValueId()); EXPECT_EQ(r1->resetValueId(), r2->resetValueId()); } + +void expectEqualFileContents(const std::string &fileName, const std::string &fileContents) +{ + // Uncomment the below when you want to generate the expected file contents. + // #define NEW_GENERATOR + +#ifdef NEW_GENERATOR + std::ofstream file(resourcePath(fileName)); + + file << fileContents; + + file.close(); +#endif + + EXPECT_EQ(::fileContents(fileName), fileContents); +} diff --git a/tests/test_utils.h b/tests/test_utils.h index b446ac238..c89198426 100644 --- a/tests/test_utils.h +++ b/tests/test_utils.h @@ -104,6 +104,7 @@ void TEST_EXPORT expectEqualIssuesCellmlElementTypesLevelsReferenceRulesUrls(con const std::vector &referenceRules, const std::vector &urls, const libcellml::LoggerPtr &logger); +void TEST_EXPORT expectEqualFileContents(const std::string &fileName, const std::string &fileContents); libcellml::ModelPtr TEST_EXPORT createModel(const std::string &name = ""); libcellml::ModelPtr TEST_EXPORT createModelWithComponent(const std::string &modelName = "", @@ -128,3 +129,7 @@ void TEST_EXPORT compareModel(const libcellml::ModelPtr &m1, const libcellml::Mo #define EXPECT_EQ_ISSUES_CELLMLELEMENTTYPES_LEVELS_REFERENCERULES_URLS(issues, cellmlElementTypes, levels, referenceRules, urls, logger) \ SCOPED_TRACE("Issue occurred here."); \ expectEqualIssuesCellmlElementTypesLevelsReferenceRulesUrls(issues, cellmlElementTypes, levels, referenceRules, urls, logger) + +#define EXPECT_EQ_FILE_CONTENTS(fileName, fileContents) \ + SCOPED_TRACE("Issue occurred here."); \ + expectEqualFileContents(fileName, fileContents) From c2504d7d68eaef3945f7765ddd42c31e624a4829 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 7 Aug 2024 18:00:09 +0200 Subject: [PATCH 10/74] Generator profile: added setters/getters for constants, computed constants, and algebraic arrays. --- src/api/libcellml/generatorprofile.h | 56 +- src/bindings/interface/generatorprofile.i | 20 +- src/bindings/javascript/generatorprofile.cpp | 8 +- src/generator.cpp | 18 +- src/generatorprofile.cpp | 40 +- src/generatorprofilesha1values.h | 4 +- src/generatorprofiletools.cpp | 4 +- .../javascript/generatorprofile.test.js | 18 +- .../bindings/python/test_generator_profile.py | 26 +- tests/generator/generatorprofile.cpp | 12 +- tests/resources/coverage/generator/model.c | 434 +++++------ .../generator/model.implementation.out | 434 +++++------ .../generator/model.modified.profile.c | 434 +++++------ .../generator/model.modified.profile.py | 434 +++++------ tests/resources/coverage/generator/model.out | 434 +++++------ tests/resources/coverage/generator/model.py | 434 +++++------ .../algebraic_eqn_computed_var_on_rhs/model.c | 4 +- .../model.external.c | 6 +- .../model.external.py | 6 +- .../model.py | 4 +- .../algebraic_eqn_const_var_on_rhs/model.c | 4 +- .../algebraic_eqn_const_var_on_rhs/model.py | 4 +- .../algebraic_eqn_constant_on_rhs/model.c | 2 +- .../algebraic_eqn_constant_on_rhs/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs/model.c | 6 +- .../algebraic_eqn_derivative_on_rhs/model.py | 6 +- .../model.c | 6 +- .../model.py | 6 +- .../algebraic_eqn_state_var_on_rhs/model.c | 6 +- .../algebraic_eqn_state_var_on_rhs/model.py | 6 +- .../model.c | 6 +- .../model.py | 6 +- .../model.c | 16 +- .../model.external.c | 10 +- .../model.external.py | 10 +- .../model.py | 16 +- .../model.c | 30 +- .../model.py | 30 +- .../model.three.externals.c | 12 +- .../model.three.externals.py | 12 +- .../model.not.ordered.c | 28 +- .../model.not.ordered.py | 28 +- .../model.ordered.c | 28 +- .../model.ordered.py | 28 +- .../algebraic_unknown_var_on_rhs/model.c | 4 +- .../algebraic_unknown_var_on_rhs/model.py | 4 +- .../generator/cell_geometry_model/model.c | 8 +- .../cell_geometry_model/model.external.c | 12 +- .../cell_geometry_model/model.external.py | 12 +- .../generator/cell_geometry_model/model.py | 8 +- .../model.c | 4 +- .../model.py | 4 +- .../generator/cellml_slc_example/model.py | 20 +- .../model.c | 4 +- .../model.py | 4 +- .../cellml_unit_scaling_constant/model.c | 6 +- .../cellml_unit_scaling_constant/model.py | 6 +- .../cellml_unit_scaling_rate/model.c | 4 +- .../cellml_unit_scaling_rate/model.py | 4 +- .../cellml_unit_scaling_state/model.c | 4 +- .../cellml_unit_scaling_state/model.py | 4 +- .../model.c | 8 +- .../model.py | 8 +- .../generator/dae_cellml_1_1_model/model.c | 46 +- .../generator/dae_cellml_1_1_model/model.py | 46 +- .../generator/dependent_eqns/model.c | 4 +- .../generator/dependent_eqns/model.py | 4 +- .../model.c | 690 +++++++++--------- .../model.py | 690 +++++++++--------- .../model.c | 504 ++++++------- .../model.py | 504 ++++++------- .../model.algebraic.c | 66 +- .../model.algebraic.py | 66 +- .../model.c | 62 +- .../model.computed.constant.c | 66 +- .../model.computed.constant.py | 66 +- .../model.constant.c | 66 +- .../model.constant.py | 66 +- .../model.dae.c | 148 ++-- .../model.dae.py | 148 ++-- .../model.dependent.algebraic.c | 68 +- .../model.dependent.algebraic.py | 68 +- .../model.dependent.computed.constant.c | 74 +- .../model.dependent.computed.constant.py | 74 +- .../model.dependent.constant.c | 70 +- .../model.dependent.constant.py | 70 +- .../model.dependent.state.c | 50 +- .../model.dependent.state.py | 50 +- .../model.external.c | 54 +- .../model.external.py | 54 +- .../model.py | 62 +- .../model.state.c | 62 +- .../model.state.py | 62 +- .../generator/noble_model_1962/model.c | 66 +- .../generator/noble_model_1962/model.py | 66 +- .../generator/ode_computed_var_on_rhs/model.c | 4 +- .../ode_computed_var_on_rhs/model.py | 4 +- .../model.c | 4 +- .../model.py | 4 +- .../generator/ode_const_var_on_rhs/model.c | 4 +- .../generator/ode_const_var_on_rhs/model.py | 4 +- .../model.c | 4 +- .../model.py | 4 +- .../ode_multiple_dependent_odes/model.c | 4 +- .../ode_multiple_dependent_odes/model.py | 4 +- .../model.c | 4 +- .../model.py | 4 +- .../ode_multiple_odes_with_same_name/model.c | 4 +- .../ode_multiple_odes_with_same_name/model.py | 4 +- .../robertson_model_1966/model.dae.c | 22 +- .../robertson_model_1966/model.dae.py | 22 +- .../robertson_model_1966/model.ode.c | 14 +- .../robertson_model_1966/model.ode.py | 14 +- .../generator/sine_model_imports/model.c | 22 +- .../generator/sine_model_imports/model.py | 22 +- .../model.c | 22 +- .../model.py | 22 +- .../model.c | 4 +- .../model.py | 4 +- 119 files changed, 3904 insertions(+), 3778 deletions(-) diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index cb85018fb..cbbb42f1a 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -3034,23 +3034,61 @@ class LIBCELLML_EXPORT GeneratorProfile void setRatesArrayString(const std::string &ratesArrayString); /** - * @brief Get the @c std::string for the name of the variables array. + * @brief Get the @c std::string for the name of the constants array. * - * Return the @c std::string for the name of the variables array. + * Return the @c std::string for the name of the constants array. * - * @return The @c std::string for the name of the variables array. + * @return The @c std::string for the name of the constants array. */ - std::string variablesArrayString() const; + std::string constantsArrayString() const; /** - * @brief Set the @c std::string for the name of the variables array. + * @brief Set the @c std::string for the name of the constants array. * - * Set the @c std::string for the name of the variables array. + * Set the @c std::string for the name of the constants array. * - * @param variablesArrayString The @c std::string to use for the name of the - * variables array. + * @param constantsArrayString The @c std::string to use for the name of the + * constants array. + */ + void setConstantsArrayString(const std::string &constantsArrayString); + + /** + * @brief Get the @c std::string for the name of the computed constants array. + * + * Return the @c std::string for the name of the computed constants array. + * + * @return The @c std::string for the name of the computed constants array. + */ + std::string computedConstantsArrayString() const; + + /** + * @brief Set the @c std::string for the name of the computed constants array. + * + * Set the @c std::string for the name of the computed constants array. + * + * @param computedConstantsArrayString The @c std::string to use for the name of the + * computed constants array. + */ + void setComputedConstantsArrayString(const std::string &computedConstantsArrayString); + + /** + * @brief Get the @c std::string for the name of the algebraic array. + * + * Return the @c std::string for the name of the algebraic array. + * + * @return The @c std::string for the name of the algebraic array. + */ + std::string algebraicArrayString() const; + + /** + * @brief Set the @c std::string for the name of the algebraic array. + * + * Set the @c std::string for the name of the algebraic array. + * + * @param algebraicArrayString The @c std::string to use for the name of the + * algebraic array. */ - void setVariablesArrayString(const std::string &variablesArrayString); + void setAlgebraicArrayString(const std::string &algebraicArrayString); /** * @brief Get the @c std::string for the type definition of an external diff --git a/src/bindings/interface/generatorprofile.i b/src/bindings/interface/generatorprofile.i index e8da17ba3..8c694e9f5 100644 --- a/src/bindings/interface/generatorprofile.i +++ b/src/bindings/interface/generatorprofile.i @@ -833,11 +833,23 @@ and units of a variable respectively."; %feature("docstring") libcellml::GeneratorProfile::setRatesArrayString "Sets the string for the name of the rates array."; -%feature("docstring") libcellml::GeneratorProfile::variablesArrayString -"Returns the string for the name of the variables array."; +%feature("docstring") libcellml::GeneratorProfile::constantsArrayString +"Returns the string for the name of the constants array."; -%feature("docstring") libcellml::GeneratorProfile::setVariablesArrayString -"Sets the string for the name of the variables array."; +%feature("docstring") libcellml::GeneratorProfile::setConstantsArrayString +"Sets the string for the name of the constants array."; + +%feature("docstring") libcellml::GeneratorProfile::computedConstantsArrayString +"Returns the string for the name of the computed constants array."; + +%feature("docstring") libcellml::GeneratorProfile::setComputedConstantsArrayString +"Sets the string for the name of the computed constants array."; + +%feature("docstring") libcellml::GeneratorProfile::algebraicArrayString +"Returns the string for the name of the algebraic array."; + +%feature("docstring") libcellml::GeneratorProfile::setAlgebraicArrayString +"Sets the string for the name of the algebraic array."; %feature("docstring") libcellml::GeneratorProfile::externalVariableMethodTypeDefinitionString "Returns the string for the type definition of an external variable method."; diff --git a/src/bindings/javascript/generatorprofile.cpp b/src/bindings/javascript/generatorprofile.cpp index 97a6ee651..e9fc6b420 100644 --- a/src/bindings/javascript/generatorprofile.cpp +++ b/src/bindings/javascript/generatorprofile.cpp @@ -299,8 +299,12 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setStatesArrayString", &libcellml::GeneratorProfile::setStatesArrayString) .function("ratesArrayString", &libcellml::GeneratorProfile::ratesArrayString) .function("setRatesArrayString", &libcellml::GeneratorProfile::setRatesArrayString) - .function("variablesArrayString", &libcellml::GeneratorProfile::variablesArrayString) - .function("setVariablesArrayString", &libcellml::GeneratorProfile::setVariablesArrayString) + .function("constantsArrayString", &libcellml::GeneratorProfile::constantsArrayString) + .function("setConstantsArrayString", &libcellml::GeneratorProfile::setConstantsArrayString) + .function("computedConstantsArrayString", &libcellml::GeneratorProfile::computedConstantsArrayString) + .function("setComputedConstantsArrayString", &libcellml::GeneratorProfile::setComputedConstantsArrayString) + .function("algebraicArrayString", &libcellml::GeneratorProfile::algebraicArrayString) + .function("setAlgebraicArrayString", &libcellml::GeneratorProfile::setAlgebraicArrayString) .function("externalVariableMethodTypeDefinitionString", &libcellml::GeneratorProfile::externalVariableMethodTypeDefinitionString) .function("setExternalVariableMethodTypeDefinitionString", &libcellml::GeneratorProfile::setExternalVariableMethodTypeDefinitionString) .function("externalVariableMethodCallString", &libcellml::GeneratorProfile::externalVariableMethodCallString) diff --git a/src/generator.cpp b/src/generator.cpp index 51a4e51b4..553234430 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -810,7 +810,11 @@ void Generator::GeneratorImpl::addNlaSystemsCode() for (i = 0; i < variablesCount; ++i) { auto arrayString = (variables[i]->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - mProfile->variablesArrayString(); + (variables[i]->type() == AnalyserVariable::Type::CONSTANT) ? + mProfile->constantsArrayString() : + (variables[i]->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) ? + mProfile->computedConstantsArrayString() : + mProfile->algebraicArrayString(); methodBody += mProfile->indentString() + arrayString + mProfile->openArrayString() + convertToString(variables[i]->index()) + mProfile->closeArrayString() @@ -851,7 +855,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() for (i = 0; i < variablesCount; ++i) { auto arrayString = (variables[i]->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - mProfile->variablesArrayString(); + mProfile->algebraicArrayString(); methodBody += mProfile->indentString() + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(i) + mProfile->closeArrayString() @@ -871,7 +875,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() for (i = 0; i < variablesCount; ++i) { auto arrayString = (variables[i]->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - mProfile->variablesArrayString(); + mProfile->algebraicArrayString(); methodBody += mProfile->indentString() + arrayString + mProfile->openArrayString() + convertToString(variables[i]->index()) + mProfile->closeArrayString() @@ -923,7 +927,7 @@ std::string Generator::GeneratorImpl::generateDoubleOrConstantVariableNameCode(c auto initValueVariable = owningComponent(variable)->variable(variable->initialValue()); auto analyserInitialValueVariable = analyserVariable(initValueVariable); - return mProfile->variablesArrayString() + mProfile->openArrayString() + convertToString(analyserInitialValueVariable->index()) + mProfile->closeArrayString(); + return mProfile->constantsArrayString() + mProfile->openArrayString() + convertToString(analyserInitialValueVariable->index()) + mProfile->closeArrayString(); } std::string Generator::GeneratorImpl::generateVariableNameCode(const VariablePtr &variable, @@ -950,8 +954,12 @@ std::string Generator::GeneratorImpl::generateVariableNameCode(const VariablePtr arrayName = state ? mProfile->statesArrayString() : mProfile->ratesArrayString(); + } else if (analyserVariable->type() == AnalyserVariable::Type::CONSTANT) { + arrayName = mProfile->constantsArrayString(); + } else if (analyserVariable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) { + arrayName = mProfile->computedConstantsArrayString(); } else { - arrayName = mProfile->variablesArrayString(); + arrayName = mProfile->algebraicArrayString(); } return arrayName + mProfile->openArrayString() + convertToString(analyserVariable->index()) + mProfile->closeArrayString(); diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 3dd23d980..67dd5160d 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -222,7 +222,9 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mStatesArrayString; std::string mRatesArrayString; - std::string mVariablesArrayString; + std::string mConstantsArrayString; + std::string mComputedConstantsArrayString; + std::string mAlgebraicArrayString; std::string mExternalVariableMethodTypeDefinitionFamString; std::string mExternalVariableMethodTypeDefinitionFdmString; @@ -580,7 +582,9 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mStatesArrayString = "states"; mRatesArrayString = "rates"; - mVariablesArrayString = "variables"; + mConstantsArrayString = "constants"; + mComputedConstantsArrayString = "computedConstants"; + mAlgebraicArrayString = "algebraic"; mExternalVariableMethodTypeDefinitionFamString = "typedef double (* ExternalVariable)(double *variables, size_t index);\n"; mExternalVariableMethodTypeDefinitionFdmString = "typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index);\n"; @@ -1014,7 +1018,9 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mStatesArrayString = "states"; mRatesArrayString = "rates"; - mVariablesArrayString = "variables"; + mConstantsArrayString = "constants"; + mComputedConstantsArrayString = "computed_constants"; + mAlgebraicArrayString = "algebraic"; mExternalVariableMethodTypeDefinitionFamString = ""; mExternalVariableMethodTypeDefinitionFdmString = ""; @@ -2535,14 +2541,34 @@ void GeneratorProfile::setRatesArrayString(const std::string &ratesArrayString) mPimpl->mRatesArrayString = ratesArrayString; } -std::string GeneratorProfile::variablesArrayString() const +std::string GeneratorProfile::constantsArrayString() const { - return mPimpl->mVariablesArrayString; + return mPimpl->mConstantsArrayString; } -void GeneratorProfile::setVariablesArrayString(const std::string &variablesArrayString) +void GeneratorProfile::setConstantsArrayString(const std::string &constantsArrayString) { - mPimpl->mVariablesArrayString = variablesArrayString; + mPimpl->mConstantsArrayString = constantsArrayString; +} + +std::string GeneratorProfile::computedConstantsArrayString() const +{ + return mPimpl->mComputedConstantsArrayString; +} + +void GeneratorProfile::setComputedConstantsArrayString(const std::string &computedConstantsArrayString) +{ + mPimpl->mComputedConstantsArrayString = computedConstantsArrayString; +} + +std::string GeneratorProfile::algebraicArrayString() const +{ + return mPimpl->mAlgebraicArrayString; +} + +void GeneratorProfile::setAlgebraicArrayString(const std::string &algebraicArrayString) +{ + mPimpl->mAlgebraicArrayString = algebraicArrayString; } std::string GeneratorProfile::externalVariableMethodTypeDefinitionString(bool forDifferentialModel) const diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 0bae464fb..69f2ae4d9 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "060945ab10d8ce4ce063e4b64199f684ec0150a5"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "859d7920e76c1a12345a2d642940163d41d27112"; +static const char C_GENERATOR_PROFILE_SHA1[] = "f36d3c679b030a09095376711d4dc9a638a5c7b3"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "bb03c147d17a9741667957068ef629058846d2e4"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index 4a1613b8d..6293fd120 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -480,7 +480,9 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->statesArrayString() + generatorProfile->ratesArrayString() - + generatorProfile->variablesArrayString(); + + generatorProfile->constantsArrayString() + + generatorProfile->computedConstantsArrayString() + + generatorProfile->algebraicArrayString(); profileContents += generatorProfile->externalVariableMethodTypeDefinitionString(false) + generatorProfile->externalVariableMethodTypeDefinitionString(true); diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index 7c5bd368e..92fe3b586 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -897,11 +897,23 @@ describe("GeneratorProfile tests", () => { x.setRatesArrayString("something") expect(x.ratesArrayString()).toBe("something") }); - test("Checking GeneratorProfile.variablesArrayString.", () => { + test("Checking GeneratorProfile.constantsArrayString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setVariablesArrayString("something") - expect(x.variablesArrayString()).toBe("something") + x.setConstantsArrayString("something") + expect(x.constantsArrayString()).toBe("something") + }); + test("Checking GeneratorProfile.computedConstantsArrayString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setComputedConstantsArrayString("something") + expect(x.computedConstantsArrayString()).toBe("something") + }); + test("Checking GeneratorProfile.algebraicArrayString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setAlgebraicArrayString("something") + expect(x.algebraicArrayString()).toBe("something") }); test("Checking GeneratorProfile.externalVariableMethodTypeDefinitionString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 4eb8a46fa..aaa7e3271 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -1607,14 +1607,32 @@ def test_variable_type_object_string(self): g.setVariableTypeObjectString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.variableTypeObjectString(True, True)) - def test_variables_array_string(self): + def test_constants_array_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('variables', g.variablesArrayString()) - g.setVariablesArrayString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.variablesArrayString()) + self.assertEqual('constants', g.constantsArrayString()) + g.setConstantsArrayString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.constantsArrayString()) + + def test_computed_constants_array_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('computedConstants', g.computedConstantsArrayString()) + g.setComputedConstantsArrayString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.computedConstantsArrayString()) + + def test_algebraic_array_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('algebraic', g.algebraicArrayString()) + g.setAlgebraicArrayString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.algebraicArrayString()) def test_external_variable_method_type_definition_string(self): from libcellml import GeneratorProfile diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index f690252bc..539e28a06 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -355,7 +355,9 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("states", generatorProfile->statesArrayString()); EXPECT_EQ("rates", generatorProfile->ratesArrayString()); - EXPECT_EQ("variables", generatorProfile->variablesArrayString()); + EXPECT_EQ("constants", generatorProfile->constantsArrayString()); + EXPECT_EQ("computedConstants", generatorProfile->computedConstantsArrayString()); + EXPECT_EQ("algebraic", generatorProfile->algebraicArrayString()); EXPECT_EQ("typedef double (* ExternalVariable)(double *variables, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(false)); EXPECT_EQ("typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(true)); @@ -909,7 +911,9 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setStatesArrayString(value); generatorProfile->setRatesArrayString(value); - generatorProfile->setVariablesArrayString(value); + generatorProfile->setConstantsArrayString(value); + generatorProfile->setComputedConstantsArrayString(value); + generatorProfile->setAlgebraicArrayString(value); generatorProfile->setExternalVariableMethodTypeDefinitionString(false, value); generatorProfile->setExternalVariableMethodTypeDefinitionString(true, value); @@ -1044,7 +1048,9 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->statesArrayString()); EXPECT_EQ(value, generatorProfile->ratesArrayString()); - EXPECT_EQ(value, generatorProfile->variablesArrayString()); + EXPECT_EQ(value, generatorProfile->constantsArrayString()); + EXPECT_EQ(value, generatorProfile->computedConstantsArrayString()); + EXPECT_EQ(value, generatorProfile->algebraicArrayString()); EXPECT_EQ(value, generatorProfile->externalVariableMethodTypeDefinitionString(false)); EXPECT_EQ(value, generatorProfile->externalVariableMethodTypeDefinitionString(true)); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index e5bf4ccdf..872419de4 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -356,11 +356,11 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[205] = u[0]; - variables[206] = u[1]; + algebraic[205] = u[0]; + algebraic[206] = u[1]; - f[0] = variables[205]+variables[206]+states[0]-0.0; - f[1] = variables[205]-variables[206]-(variables[207]+variables[208]); + f[0] = algebraic[205]+algebraic[206]+states[0]-0.0; + f[1] = algebraic[205]-algebraic[206]-(computedConstants[207]+computedConstants[208]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -368,231 +368,231 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[2]; - u[0] = variables[205]; - u[1] = variables[206]; + u[0] = algebraic[205]; + u[1] = algebraic[206]; nlaSolve(objectiveFunction0, u, 2, &rfi); - variables[205] = u[0]; - variables[206] = u[1]; + algebraic[205] = u[0]; + algebraic[206] = u[1]; } void initialiseVariables(double *states, double *rates, double *constants) { - variables[1] = 1.0; - variables[2] = 2.0; - variables[6] = 3.0; - variables[18] = 4.0; - variables[179] = 5.0; - variables[180] = 6.0; - variables[182] = 7.0; - variables[205] = 1.0; - variables[206] = 2.0; - variables[184] = 123.0; - variables[185] = 123.456789; - variables[186] = 123.0e99; - variables[187] = 123.456789e99; - variables[189] = 1.0; - variables[190] = 0.0; - variables[191] = 2.71828182845905; - variables[192] = 3.14159265358979; - variables[193] = INFINITY; - variables[194] = NAN; - variables[207] = 1.0; - variables[208] = 3.0; + constants[1] = 1.0; + constants[2] = 2.0; + constants[6] = 3.0; + constants[18] = 4.0; + constants[179] = 5.0; + constants[180] = 6.0; + constants[182] = 7.0; + algebraic[205] = 1.0; + algebraic[206] = 2.0; + computedConstants[184] = 123.0; + computedConstants[185] = 123.456789; + computedConstants[186] = 123.0e99; + computedConstants[187] = 123.456789e99; + computedConstants[189] = 1.0; + computedConstants[190] = 0.0; + computedConstants[191] = 2.71828182845905; + computedConstants[192] = 3.14159265358979; + computedConstants[193] = INFINITY; + computedConstants[194] = NAN; + computedConstants[207] = 1.0; + computedConstants[208] = 3.0; states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { - variables[0] = variables[1] == variables[2]; - variables[3] = variables[1]/(variables[2] == variables[2]); - variables[4] = variables[1] != variables[2]; - variables[5] = variables[1]/(variables[2] != variables[6]); - variables[7] = variables[1] < variables[2]; - variables[8] = variables[1]/(variables[2] < variables[6]); - variables[9] = variables[1] <= variables[2]; - variables[10] = variables[1]/(variables[2] <= variables[6]); - variables[11] = variables[1] > variables[2]; - variables[12] = variables[1]/(variables[2] > variables[6]); - variables[13] = variables[1] >= variables[2]; - variables[14] = variables[1]/(variables[2] >= variables[6]); - variables[15] = variables[1] && variables[2]; - variables[16] = variables[1] && variables[2] && variables[6]; - variables[17] = (variables[1] < variables[2]) && (variables[6] > variables[18]); - variables[19] = (variables[1]+variables[2]) && (variables[6] > variables[18]); - variables[20] = variables[1] && (variables[2] > variables[6]); - variables[21] = (variables[1]-variables[2]) && (variables[6] > variables[18]); - variables[22] = -variables[1] && (variables[2] > variables[6]); - variables[23] = pow(variables[1], variables[2]) && (variables[6] > variables[18]); - variables[24] = pow(variables[1], 1.0/variables[2]) && (variables[6] > variables[18]); - variables[25] = (variables[1] < variables[2]) && (variables[6]+variables[18]); - variables[26] = (variables[1] < variables[2]) && variables[6]; - variables[27] = (variables[1] < variables[2]) && (variables[6]-variables[18]); - variables[28] = (variables[1] < variables[2]) && -variables[6]; - variables[29] = (variables[1] < variables[2]) && pow(variables[6], variables[18]); - variables[30] = (variables[1] < variables[2]) && pow(variables[6], 1.0/variables[18]); - variables[31] = variables[1]/(variables[2] && variables[6]); - variables[32] = variables[1] || variables[2]; - variables[33] = variables[1] || variables[2] || variables[6]; - variables[34] = (variables[1] < variables[2]) || (variables[6] > variables[18]); - variables[35] = (variables[1]+variables[2]) || (variables[6] > variables[18]); - variables[36] = variables[1] || (variables[2] > variables[6]); - variables[37] = (variables[1]-variables[2]) || (variables[6] > variables[18]); - variables[38] = -variables[1] || (variables[2] > variables[6]); - variables[39] = pow(variables[1], variables[2]) || (variables[6] > variables[18]); - variables[40] = pow(variables[1], 1.0/variables[2]) || (variables[6] > variables[18]); - variables[41] = (variables[1] < variables[2]) || (variables[6]+variables[18]); - variables[42] = (variables[1] < variables[2]) || variables[6]; - variables[43] = (variables[1] < variables[2]) || (variables[6]-variables[18]); - variables[44] = (variables[1] < variables[2]) || -variables[6]; - variables[45] = (variables[1] < variables[2]) || pow(variables[6], variables[18]); - variables[46] = (variables[1] < variables[2]) || pow(variables[6], 1.0/variables[18]); - variables[47] = variables[1]/(variables[2] || variables[6]); - variables[48] = xor(variables[1], variables[2]); - variables[49] = xor(variables[1], xor(variables[2], variables[6])); - variables[50] = xor(variables[1] < variables[2], variables[6] > variables[18]); - variables[51] = xor(variables[1]+variables[2], variables[6] > variables[18]); - variables[52] = xor(variables[1], variables[2] > variables[6]); - variables[53] = xor(variables[1]-variables[2], variables[6] > variables[18]); - variables[54] = xor(-variables[1], variables[2] > variables[6]); - variables[55] = xor(pow(variables[1], variables[2]), variables[6] > variables[18]); - variables[56] = xor(pow(variables[1], 1.0/variables[2]), variables[6] > variables[18]); - variables[57] = xor(variables[1] < variables[2], variables[6]+variables[18]); - variables[58] = xor(variables[1] < variables[2], variables[6]); - variables[59] = xor(variables[1] < variables[2], variables[6]-variables[18]); - variables[60] = xor(variables[1] < variables[2], -variables[6]); - variables[61] = xor(variables[1] < variables[2], pow(variables[6], variables[18])); - variables[62] = xor(variables[1] < variables[2], pow(variables[6], 1.0/variables[18])); - variables[63] = variables[1]/xor(variables[2], variables[6]); - variables[64] = !variables[1]; - variables[65] = variables[1]+variables[2]; - variables[66] = variables[1]+variables[2]+variables[6]; - variables[67] = (variables[1] < variables[2])+(variables[6] > variables[18]); - variables[68] = variables[1]; - variables[69] = variables[1]-variables[2]; - variables[70] = (variables[1] < variables[2])-(variables[6] > variables[18]); - variables[71] = (variables[1] < variables[2])-(variables[6]+variables[18]); - variables[72] = (variables[1] < variables[2])-variables[6]; - variables[73] = variables[1]-(-variables[2]); - variables[74] = variables[1]-(-variables[2]*variables[6]); - variables[75] = -variables[1]; - variables[76] = -(variables[1] < variables[2]); - variables[77] = variables[1]*variables[2]; - variables[78] = variables[1]*variables[2]*variables[6]; - variables[79] = (variables[1] < variables[2])*(variables[6] > variables[18]); - variables[80] = (variables[1]+variables[2])*(variables[6] > variables[18]); - variables[81] = variables[1]*(variables[2] > variables[6]); - variables[82] = (variables[1]-variables[2])*(variables[6] > variables[18]); - variables[83] = -variables[1]*(variables[2] > variables[6]); - variables[84] = (variables[1] < variables[2])*(variables[6]+variables[18]); - variables[85] = (variables[1] < variables[2])*variables[6]; - variables[86] = (variables[1] < variables[2])*(variables[6]-variables[18]); - variables[87] = (variables[1] < variables[2])*-variables[6]; - variables[88] = variables[1]/variables[2]; - variables[89] = (variables[1] < variables[2])/(variables[18] > variables[6]); - variables[90] = (variables[1]+variables[2])/(variables[18] > variables[6]); - variables[91] = variables[1]/(variables[6] > variables[2]); - variables[92] = (variables[1]-variables[2])/(variables[18] > variables[6]); - variables[93] = -variables[1]/(variables[6] > variables[2]); - variables[94] = (variables[1] < variables[2])/(variables[6]+variables[18]); - variables[95] = (variables[1] < variables[2])/variables[6]; - variables[96] = (variables[1] < variables[2])/(variables[6]-variables[18]); - variables[97] = (variables[1] < variables[2])/-variables[6]; - variables[98] = (variables[1] < variables[2])/(variables[6]*variables[18]); - variables[99] = (variables[1] < variables[2])/(variables[6]/variables[18]); - variables[100] = sqrt(variables[1]); - variables[101] = pow(variables[1], 2.0); - variables[102] = pow(variables[1], 3.0); - variables[103] = pow(variables[1], variables[2]); - variables[104] = pow(variables[1] <= variables[2], variables[6] >= variables[18]); - variables[105] = pow(variables[1]+variables[2], variables[6] >= variables[18]); - variables[106] = pow(variables[1], variables[2] >= variables[6]); - variables[107] = pow(variables[1]-variables[2], variables[6] >= variables[18]); - variables[108] = pow(-variables[1], variables[2] >= variables[6]); - variables[109] = pow(variables[1]*variables[2], variables[6] >= variables[18]); - variables[110] = pow(variables[1]/variables[2], variables[6] >= variables[18]); - variables[111] = pow(variables[1] <= variables[2], variables[6]+variables[18]); - variables[112] = pow(variables[1] <= variables[2], variables[6]); - variables[113] = pow(variables[1] <= variables[2], variables[6]-variables[18]); - variables[114] = pow(variables[1] <= variables[2], -variables[6]); - variables[115] = pow(variables[1] <= variables[2], variables[6]*variables[18]); - variables[116] = pow(variables[1] <= variables[2], variables[6]/variables[18]); - variables[117] = pow(variables[1] <= variables[2], pow(variables[6], variables[18])); - variables[118] = pow(variables[1] <= variables[2], pow(variables[6], 1.0/variables[18])); - variables[119] = sqrt(variables[1]); - variables[120] = sqrt(variables[1]); - variables[121] = pow(variables[1], 1.0/3.0); - variables[122] = pow(variables[1], 1.0/variables[2]); - variables[123] = pow(variables[1] < variables[2], 1.0/(variables[18] > variables[6])); - variables[124] = pow(variables[1]+variables[2], 1.0/(variables[18] > variables[6])); - variables[125] = pow(variables[1], 1.0/(variables[6] > variables[2])); - variables[126] = pow(variables[1]-variables[2], 1.0/(variables[18] > variables[6])); - variables[127] = pow(-variables[1], 1.0/(variables[6] > variables[2])); - variables[128] = pow(variables[1]*variables[2], 1.0/(variables[18] > variables[6])); - variables[129] = pow(variables[1]/variables[2], 1.0/(variables[18] > variables[6])); - variables[130] = pow(variables[1] < variables[2], 1.0/(variables[6]+variables[18])); - variables[131] = pow(variables[1] < variables[2], 1.0/variables[6]); - variables[132] = pow(variables[1] < variables[2], 1.0/(variables[6]-variables[18])); - variables[133] = pow(variables[1] < variables[2], 1.0/-variables[6]); - variables[134] = pow(variables[1] < variables[2], 1.0/(variables[6]*variables[18])); - variables[135] = pow(variables[1] < variables[2], 1.0/(variables[6]/variables[18])); - variables[136] = pow(variables[1] < variables[2], 1.0/pow(variables[6], variables[18])); - variables[137] = pow(variables[1] < variables[2], 1.0/pow(variables[6], 1.0/variables[18])); - variables[138] = fabs(variables[1]); - variables[139] = exp(variables[1]); - variables[140] = log(variables[1]); - variables[141] = log10(variables[1]); - variables[142] = log(variables[1])/log(2.0); - variables[143] = log10(variables[1]); - variables[144] = log(variables[1])/log(variables[2]); - variables[145] = ceil(variables[1]); - variables[146] = floor(variables[1]); - variables[147] = min(variables[1], variables[2]); - variables[148] = min(variables[1], min(variables[2], variables[6])); - variables[149] = max(variables[1], variables[2]); - variables[150] = max(variables[1], max(variables[2], variables[6])); - variables[151] = fmod(variables[1], variables[2]); - variables[152] = sin(variables[1]); - variables[153] = cos(variables[1]); - variables[154] = tan(variables[1]); - variables[155] = sec(variables[1]); - variables[156] = csc(variables[1]); - variables[157] = cot(variables[1]); - variables[158] = sinh(variables[1]); - variables[159] = cosh(variables[1]); - variables[160] = tanh(variables[1]); - variables[161] = sech(variables[1]); - variables[162] = csch(variables[1]); - variables[163] = coth(variables[1]); - variables[164] = asin(variables[1]); - variables[165] = acos(variables[1]); - variables[166] = atan(variables[1]); - variables[167] = asec(variables[1]); - variables[168] = acsc(variables[1]); - variables[169] = acot(variables[1]); - variables[170] = asinh(variables[1]); - variables[171] = acosh(variables[1]); - variables[172] = atanh(variables[1]/2.0); - variables[173] = asech(variables[1]); - variables[174] = acsch(variables[1]); - variables[175] = acoth(2.0*variables[1]); - variables[176] = (variables[1] > variables[2])?variables[1]:NAN; - variables[177] = (variables[1] > variables[2])?variables[1]:variables[6]; - variables[178] = (variables[1] > variables[2])?variables[1]:(variables[6] > variables[18])?variables[6]:(variables[179] > variables[180])?variables[179]:NAN; - variables[181] = (variables[1] > variables[2])?variables[1]:(variables[6] > variables[18])?variables[6]:(variables[179] > variables[180])?variables[179]:variables[182]; - variables[183] = 123.0+((variables[1] > variables[2])?variables[1]:NAN); - variables[188] = variables[1]; - variables[195] = (variables[1] && variables[2])+((variables[6] > variables[18])?variables[2]:NAN)+variables[179]+(variables[180] && variables[182]); - variables[196] = (variables[1] && variables[2])-(((variables[6] > variables[18])?variables[2]:NAN)-(variables[179]-((variables[6] > variables[18])?variables[2]:NAN)))-(variables[180] && variables[182]); - variables[197] = (variables[1] && variables[2])*((variables[6] > variables[18])?variables[2]:NAN)*variables[179]*((variables[6] > variables[18])?variables[2]:NAN)*(variables[180] && variables[182]); - variables[198] = (variables[1] && variables[2])/(((variables[6] > variables[18])?variables[2]:NAN)/(variables[179]/((variables[6] > variables[18])?variables[2]:NAN))); - variables[199] = (variables[1] || variables[2]) && xor(variables[1], variables[2]) && ((variables[6] > variables[18])?variables[2]:NAN) && variables[179] && ((variables[6] > variables[18])?variables[2]:NAN) && xor(variables[1], variables[2]) && (variables[1] || variables[2]); - variables[200] = (variables[1] && variables[2]) || xor(variables[1], variables[2]) || ((variables[6] > variables[18])?variables[2]:NAN) || variables[179] || ((variables[6] > variables[18])?variables[2]:NAN) || xor(variables[1], variables[2]) || (variables[1] && variables[2]); - variables[201] = xor(variables[1] && variables[2], xor(variables[1] || variables[2], xor((variables[6] > variables[18])?variables[2]:NAN, xor(xor(xor(variables[179], (variables[6] > variables[18])?variables[2]:NAN), variables[1] || variables[2]), variables[1] && variables[2])))); - variables[202] = pow(variables[1] && variables[2], pow((variables[6] > variables[18])?variables[2]:NAN, pow(pow(variables[179], (variables[6] > variables[18])?variables[2]:NAN), variables[1] && variables[2]))); - variables[203] = pow(pow(pow(variables[1] && variables[2], 1.0/pow((variables[6] > variables[18])?variables[2]:NAN, 1.0/variables[179])), 1.0/((variables[6] > variables[18])?variables[2]:NAN)), 1.0/(variables[1] && variables[2])); - variables[204] = -(variables[1] && variables[2])+-((variables[6] > variables[18])?variables[2]:NAN); + computedConstants[0] = constants[1] == constants[2]; + computedConstants[3] = constants[1]/(constants[2] == constants[2]); + computedConstants[4] = constants[1] != constants[2]; + computedConstants[5] = constants[1]/(constants[2] != constants[6]); + computedConstants[7] = constants[1] < constants[2]; + computedConstants[8] = constants[1]/(constants[2] < constants[6]); + computedConstants[9] = constants[1] <= constants[2]; + computedConstants[10] = constants[1]/(constants[2] <= constants[6]); + computedConstants[11] = constants[1] > constants[2]; + computedConstants[12] = constants[1]/(constants[2] > constants[6]); + computedConstants[13] = constants[1] >= constants[2]; + computedConstants[14] = constants[1]/(constants[2] >= constants[6]); + computedConstants[15] = constants[1] && constants[2]; + computedConstants[16] = constants[1] && constants[2] && constants[6]; + computedConstants[17] = (constants[1] < constants[2]) && (constants[6] > constants[18]); + computedConstants[19] = (constants[1]+constants[2]) && (constants[6] > constants[18]); + computedConstants[20] = constants[1] && (constants[2] > constants[6]); + computedConstants[21] = (constants[1]-constants[2]) && (constants[6] > constants[18]); + computedConstants[22] = -constants[1] && (constants[2] > constants[6]); + computedConstants[23] = pow(constants[1], constants[2]) && (constants[6] > constants[18]); + computedConstants[24] = pow(constants[1], 1.0/constants[2]) && (constants[6] > constants[18]); + computedConstants[25] = (constants[1] < constants[2]) && (constants[6]+constants[18]); + computedConstants[26] = (constants[1] < constants[2]) && constants[6]; + computedConstants[27] = (constants[1] < constants[2]) && (constants[6]-constants[18]); + computedConstants[28] = (constants[1] < constants[2]) && -constants[6]; + computedConstants[29] = (constants[1] < constants[2]) && pow(constants[6], constants[18]); + computedConstants[30] = (constants[1] < constants[2]) && pow(constants[6], 1.0/constants[18]); + computedConstants[31] = constants[1]/(constants[2] && constants[6]); + computedConstants[32] = constants[1] || constants[2]; + computedConstants[33] = constants[1] || constants[2] || constants[6]; + computedConstants[34] = (constants[1] < constants[2]) || (constants[6] > constants[18]); + computedConstants[35] = (constants[1]+constants[2]) || (constants[6] > constants[18]); + computedConstants[36] = constants[1] || (constants[2] > constants[6]); + computedConstants[37] = (constants[1]-constants[2]) || (constants[6] > constants[18]); + computedConstants[38] = -constants[1] || (constants[2] > constants[6]); + computedConstants[39] = pow(constants[1], constants[2]) || (constants[6] > constants[18]); + computedConstants[40] = pow(constants[1], 1.0/constants[2]) || (constants[6] > constants[18]); + computedConstants[41] = (constants[1] < constants[2]) || (constants[6]+constants[18]); + computedConstants[42] = (constants[1] < constants[2]) || constants[6]; + computedConstants[43] = (constants[1] < constants[2]) || (constants[6]-constants[18]); + computedConstants[44] = (constants[1] < constants[2]) || -constants[6]; + computedConstants[45] = (constants[1] < constants[2]) || pow(constants[6], constants[18]); + computedConstants[46] = (constants[1] < constants[2]) || pow(constants[6], 1.0/constants[18]); + computedConstants[47] = constants[1]/(constants[2] || constants[6]); + computedConstants[48] = xor(constants[1], constants[2]); + computedConstants[49] = xor(constants[1], xor(constants[2], constants[6])); + computedConstants[50] = xor(constants[1] < constants[2], constants[6] > constants[18]); + computedConstants[51] = xor(constants[1]+constants[2], constants[6] > constants[18]); + computedConstants[52] = xor(constants[1], constants[2] > constants[6]); + computedConstants[53] = xor(constants[1]-constants[2], constants[6] > constants[18]); + computedConstants[54] = xor(-constants[1], constants[2] > constants[6]); + computedConstants[55] = xor(pow(constants[1], constants[2]), constants[6] > constants[18]); + computedConstants[56] = xor(pow(constants[1], 1.0/constants[2]), constants[6] > constants[18]); + computedConstants[57] = xor(constants[1] < constants[2], constants[6]+constants[18]); + computedConstants[58] = xor(constants[1] < constants[2], constants[6]); + computedConstants[59] = xor(constants[1] < constants[2], constants[6]-constants[18]); + computedConstants[60] = xor(constants[1] < constants[2], -constants[6]); + computedConstants[61] = xor(constants[1] < constants[2], pow(constants[6], constants[18])); + computedConstants[62] = xor(constants[1] < constants[2], pow(constants[6], 1.0/constants[18])); + computedConstants[63] = constants[1]/xor(constants[2], constants[6]); + computedConstants[64] = !constants[1]; + computedConstants[65] = constants[1]+constants[2]; + computedConstants[66] = constants[1]+constants[2]+constants[6]; + computedConstants[67] = (constants[1] < constants[2])+(constants[6] > constants[18]); + computedConstants[68] = constants[1]; + computedConstants[69] = constants[1]-constants[2]; + computedConstants[70] = (constants[1] < constants[2])-(constants[6] > constants[18]); + computedConstants[71] = (constants[1] < constants[2])-(constants[6]+constants[18]); + computedConstants[72] = (constants[1] < constants[2])-constants[6]; + computedConstants[73] = constants[1]-(-constants[2]); + computedConstants[74] = constants[1]-(-constants[2]*constants[6]); + computedConstants[75] = -constants[1]; + computedConstants[76] = -(constants[1] < constants[2]); + computedConstants[77] = constants[1]*constants[2]; + computedConstants[78] = constants[1]*constants[2]*constants[6]; + computedConstants[79] = (constants[1] < constants[2])*(constants[6] > constants[18]); + computedConstants[80] = (constants[1]+constants[2])*(constants[6] > constants[18]); + computedConstants[81] = constants[1]*(constants[2] > constants[6]); + computedConstants[82] = (constants[1]-constants[2])*(constants[6] > constants[18]); + computedConstants[83] = -constants[1]*(constants[2] > constants[6]); + computedConstants[84] = (constants[1] < constants[2])*(constants[6]+constants[18]); + computedConstants[85] = (constants[1] < constants[2])*constants[6]; + computedConstants[86] = (constants[1] < constants[2])*(constants[6]-constants[18]); + computedConstants[87] = (constants[1] < constants[2])*-constants[6]; + computedConstants[88] = constants[1]/constants[2]; + computedConstants[89] = (constants[1] < constants[2])/(constants[18] > constants[6]); + computedConstants[90] = (constants[1]+constants[2])/(constants[18] > constants[6]); + computedConstants[91] = constants[1]/(constants[6] > constants[2]); + computedConstants[92] = (constants[1]-constants[2])/(constants[18] > constants[6]); + computedConstants[93] = -constants[1]/(constants[6] > constants[2]); + computedConstants[94] = (constants[1] < constants[2])/(constants[6]+constants[18]); + computedConstants[95] = (constants[1] < constants[2])/constants[6]; + computedConstants[96] = (constants[1] < constants[2])/(constants[6]-constants[18]); + computedConstants[97] = (constants[1] < constants[2])/-constants[6]; + computedConstants[98] = (constants[1] < constants[2])/(constants[6]*constants[18]); + computedConstants[99] = (constants[1] < constants[2])/(constants[6]/constants[18]); + computedConstants[100] = sqrt(constants[1]); + computedConstants[101] = pow(constants[1], 2.0); + computedConstants[102] = pow(constants[1], 3.0); + computedConstants[103] = pow(constants[1], constants[2]); + computedConstants[104] = pow(constants[1] <= constants[2], constants[6] >= constants[18]); + computedConstants[105] = pow(constants[1]+constants[2], constants[6] >= constants[18]); + computedConstants[106] = pow(constants[1], constants[2] >= constants[6]); + computedConstants[107] = pow(constants[1]-constants[2], constants[6] >= constants[18]); + computedConstants[108] = pow(-constants[1], constants[2] >= constants[6]); + computedConstants[109] = pow(constants[1]*constants[2], constants[6] >= constants[18]); + computedConstants[110] = pow(constants[1]/constants[2], constants[6] >= constants[18]); + computedConstants[111] = pow(constants[1] <= constants[2], constants[6]+constants[18]); + computedConstants[112] = pow(constants[1] <= constants[2], constants[6]); + computedConstants[113] = pow(constants[1] <= constants[2], constants[6]-constants[18]); + computedConstants[114] = pow(constants[1] <= constants[2], -constants[6]); + computedConstants[115] = pow(constants[1] <= constants[2], constants[6]*constants[18]); + computedConstants[116] = pow(constants[1] <= constants[2], constants[6]/constants[18]); + computedConstants[117] = pow(constants[1] <= constants[2], pow(constants[6], constants[18])); + computedConstants[118] = pow(constants[1] <= constants[2], pow(constants[6], 1.0/constants[18])); + computedConstants[119] = sqrt(constants[1]); + computedConstants[120] = sqrt(constants[1]); + computedConstants[121] = pow(constants[1], 1.0/3.0); + computedConstants[122] = pow(constants[1], 1.0/constants[2]); + computedConstants[123] = pow(constants[1] < constants[2], 1.0/(constants[18] > constants[6])); + computedConstants[124] = pow(constants[1]+constants[2], 1.0/(constants[18] > constants[6])); + computedConstants[125] = pow(constants[1], 1.0/(constants[6] > constants[2])); + computedConstants[126] = pow(constants[1]-constants[2], 1.0/(constants[18] > constants[6])); + computedConstants[127] = pow(-constants[1], 1.0/(constants[6] > constants[2])); + computedConstants[128] = pow(constants[1]*constants[2], 1.0/(constants[18] > constants[6])); + computedConstants[129] = pow(constants[1]/constants[2], 1.0/(constants[18] > constants[6])); + computedConstants[130] = pow(constants[1] < constants[2], 1.0/(constants[6]+constants[18])); + computedConstants[131] = pow(constants[1] < constants[2], 1.0/constants[6]); + computedConstants[132] = pow(constants[1] < constants[2], 1.0/(constants[6]-constants[18])); + computedConstants[133] = pow(constants[1] < constants[2], 1.0/-constants[6]); + computedConstants[134] = pow(constants[1] < constants[2], 1.0/(constants[6]*constants[18])); + computedConstants[135] = pow(constants[1] < constants[2], 1.0/(constants[6]/constants[18])); + computedConstants[136] = pow(constants[1] < constants[2], 1.0/pow(constants[6], constants[18])); + computedConstants[137] = pow(constants[1] < constants[2], 1.0/pow(constants[6], 1.0/constants[18])); + computedConstants[138] = fabs(constants[1]); + computedConstants[139] = exp(constants[1]); + computedConstants[140] = log(constants[1]); + computedConstants[141] = log10(constants[1]); + computedConstants[142] = log(constants[1])/log(2.0); + computedConstants[143] = log10(constants[1]); + computedConstants[144] = log(constants[1])/log(constants[2]); + computedConstants[145] = ceil(constants[1]); + computedConstants[146] = floor(constants[1]); + computedConstants[147] = min(constants[1], constants[2]); + computedConstants[148] = min(constants[1], min(constants[2], constants[6])); + computedConstants[149] = max(constants[1], constants[2]); + computedConstants[150] = max(constants[1], max(constants[2], constants[6])); + computedConstants[151] = fmod(constants[1], constants[2]); + computedConstants[152] = sin(constants[1]); + computedConstants[153] = cos(constants[1]); + computedConstants[154] = tan(constants[1]); + computedConstants[155] = sec(constants[1]); + computedConstants[156] = csc(constants[1]); + computedConstants[157] = cot(constants[1]); + computedConstants[158] = sinh(constants[1]); + computedConstants[159] = cosh(constants[1]); + computedConstants[160] = tanh(constants[1]); + computedConstants[161] = sech(constants[1]); + computedConstants[162] = csch(constants[1]); + computedConstants[163] = coth(constants[1]); + computedConstants[164] = asin(constants[1]); + computedConstants[165] = acos(constants[1]); + computedConstants[166] = atan(constants[1]); + computedConstants[167] = asec(constants[1]); + computedConstants[168] = acsc(constants[1]); + computedConstants[169] = acot(constants[1]); + computedConstants[170] = asinh(constants[1]); + computedConstants[171] = acosh(constants[1]); + computedConstants[172] = atanh(constants[1]/2.0); + computedConstants[173] = asech(constants[1]); + computedConstants[174] = acsch(constants[1]); + computedConstants[175] = acoth(2.0*constants[1]); + computedConstants[176] = (constants[1] > constants[2])?constants[1]:NAN; + computedConstants[177] = (constants[1] > constants[2])?constants[1]:constants[6]; + computedConstants[178] = (constants[1] > constants[2])?constants[1]:(constants[6] > constants[18])?constants[6]:(constants[179] > constants[180])?constants[179]:NAN; + computedConstants[181] = (constants[1] > constants[2])?constants[1]:(constants[6] > constants[18])?constants[6]:(constants[179] > constants[180])?constants[179]:constants[182]; + computedConstants[183] = 123.0+((constants[1] > constants[2])?constants[1]:NAN); + computedConstants[188] = constants[1]; + computedConstants[195] = (constants[1] && constants[2])+((constants[6] > constants[18])?constants[2]:NAN)+constants[179]+(constants[180] && constants[182]); + computedConstants[196] = (constants[1] && constants[2])-(((constants[6] > constants[18])?constants[2]:NAN)-(constants[179]-((constants[6] > constants[18])?constants[2]:NAN)))-(constants[180] && constants[182]); + computedConstants[197] = (constants[1] && constants[2])*((constants[6] > constants[18])?constants[2]:NAN)*constants[179]*((constants[6] > constants[18])?constants[2]:NAN)*(constants[180] && constants[182]); + computedConstants[198] = (constants[1] && constants[2])/(((constants[6] > constants[18])?constants[2]:NAN)/(constants[179]/((constants[6] > constants[18])?constants[2]:NAN))); + computedConstants[199] = (constants[1] || constants[2]) && xor(constants[1], constants[2]) && ((constants[6] > constants[18])?constants[2]:NAN) && constants[179] && ((constants[6] > constants[18])?constants[2]:NAN) && xor(constants[1], constants[2]) && (constants[1] || constants[2]); + computedConstants[200] = (constants[1] && constants[2]) || xor(constants[1], constants[2]) || ((constants[6] > constants[18])?constants[2]:NAN) || constants[179] || ((constants[6] > constants[18])?constants[2]:NAN) || xor(constants[1], constants[2]) || (constants[1] && constants[2]); + computedConstants[201] = xor(constants[1] && constants[2], xor(constants[1] || constants[2], xor((constants[6] > constants[18])?constants[2]:NAN, xor(xor(xor(constants[179], (constants[6] > constants[18])?constants[2]:NAN), constants[1] || constants[2]), constants[1] && constants[2])))); + computedConstants[202] = pow(constants[1] && constants[2], pow((constants[6] > constants[18])?constants[2]:NAN, pow(pow(constants[179], (constants[6] > constants[18])?constants[2]:NAN), constants[1] && constants[2]))); + computedConstants[203] = pow(pow(pow(constants[1] && constants[2], 1.0/pow((constants[6] > constants[18])?constants[2]:NAN, 1.0/constants[179])), 1.0/((constants[6] > constants[18])?constants[2]:NAN)), 1.0/(constants[1] && constants[2])); + computedConstants[204] = -(constants[1] && constants[2])+-((constants[6] > constants[18])?constants[2]:NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 35809a2b2..9656a1796 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -125,11 +125,11 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[205] = u[0]; - variables[206] = u[1]; + algebraic[205] = u[0]; + algebraic[206] = u[1]; - f[0] = variables[205]+variables[206]+states[0]-0.0; - f[1] = variables[205]-variables[206]-(variables[207]+variables[208]); + f[0] = algebraic[205]+algebraic[206]+states[0]-0.0; + f[1] = algebraic[205]-algebraic[206]-(computedConstants[207]+computedConstants[208]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -137,231 +137,231 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[2]; - u[0] = variables[205]; - u[1] = variables[206]; + u[0] = algebraic[205]; + u[1] = algebraic[206]; nlaSolve(objectiveFunction0, u, 2, &rfi); - variables[205] = u[0]; - variables[206] = u[1]; + algebraic[205] = u[0]; + algebraic[206] = u[1]; } void initialiseVariables(double *states, double *rates, double *constants) { - variables[1] = 1.0; - variables[2] = 2.0; - variables[6] = 3.0; - variables[18] = 4.0; - variables[179] = 5.0; - variables[180] = 6.0; - variables[182] = 7.0; - variables[205] = 1.0; - variables[206] = 2.0; - variables[184] = 123.0; - variables[185] = 123.456789; - variables[186] = 123.0e99; - variables[187] = 123.456789e99; - variables[189] = 1.0; - variables[190] = 0.0; - variables[191] = 2.71828182845905; - variables[192] = 3.14159265358979; - variables[193] = INFINITY; - variables[194] = NAN; - variables[207] = 1.0; - variables[208] = 3.0; + constants[1] = 1.0; + constants[2] = 2.0; + constants[6] = 3.0; + constants[18] = 4.0; + constants[179] = 5.0; + constants[180] = 6.0; + constants[182] = 7.0; + algebraic[205] = 1.0; + algebraic[206] = 2.0; + computedConstants[184] = 123.0; + computedConstants[185] = 123.456789; + computedConstants[186] = 123.0e99; + computedConstants[187] = 123.456789e99; + computedConstants[189] = 1.0; + computedConstants[190] = 0.0; + computedConstants[191] = 2.71828182845905; + computedConstants[192] = 3.14159265358979; + computedConstants[193] = INFINITY; + computedConstants[194] = NAN; + computedConstants[207] = 1.0; + computedConstants[208] = 3.0; states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { - variables[0] = eq(variables[1], variables[2]); - variables[3] = variables[1]/eq(variables[2], variables[2]); - variables[4] = neq(variables[1], variables[2]); - variables[5] = variables[1]/neq(variables[2], variables[6]); - variables[7] = lt(variables[1], variables[2]); - variables[8] = variables[1]/lt(variables[2], variables[6]); - variables[9] = leq(variables[1], variables[2]); - variables[10] = variables[1]/leq(variables[2], variables[6]); - variables[11] = gt(variables[1], variables[2]); - variables[12] = variables[1]/gt(variables[2], variables[6]); - variables[13] = geq(variables[1], variables[2]); - variables[14] = variables[1]/geq(variables[2], variables[6]); - variables[15] = and(variables[1], variables[2]); - variables[16] = and(variables[1], and(variables[2], variables[6])); - variables[17] = and(lt(variables[1], variables[2]), gt(variables[6], variables[18])); - variables[19] = and(variables[1]+variables[2], gt(variables[6], variables[18])); - variables[20] = and(variables[1], gt(variables[2], variables[6])); - variables[21] = and(variables[1]-variables[2], gt(variables[6], variables[18])); - variables[22] = and(-variables[1], gt(variables[2], variables[6])); - variables[23] = and(pow(variables[1], variables[2]), gt(variables[6], variables[18])); - variables[24] = and(pow(variables[1], 1.0/variables[2]), gt(variables[6], variables[18])); - variables[25] = and(lt(variables[1], variables[2]), variables[6]+variables[18]); - variables[26] = and(lt(variables[1], variables[2]), variables[6]); - variables[27] = and(lt(variables[1], variables[2]), variables[6]-variables[18]); - variables[28] = and(lt(variables[1], variables[2]), -variables[6]); - variables[29] = and(lt(variables[1], variables[2]), pow(variables[6], variables[18])); - variables[30] = and(lt(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])); - variables[31] = variables[1]/and(variables[2], variables[6]); - variables[32] = or(variables[1], variables[2]); - variables[33] = or(variables[1], or(variables[2], variables[6])); - variables[34] = or(lt(variables[1], variables[2]), gt(variables[6], variables[18])); - variables[35] = or(variables[1]+variables[2], gt(variables[6], variables[18])); - variables[36] = or(variables[1], gt(variables[2], variables[6])); - variables[37] = or(variables[1]-variables[2], gt(variables[6], variables[18])); - variables[38] = or(-variables[1], gt(variables[2], variables[6])); - variables[39] = or(pow(variables[1], variables[2]), gt(variables[6], variables[18])); - variables[40] = or(pow(variables[1], 1.0/variables[2]), gt(variables[6], variables[18])); - variables[41] = or(lt(variables[1], variables[2]), variables[6]+variables[18]); - variables[42] = or(lt(variables[1], variables[2]), variables[6]); - variables[43] = or(lt(variables[1], variables[2]), variables[6]-variables[18]); - variables[44] = or(lt(variables[1], variables[2]), -variables[6]); - variables[45] = or(lt(variables[1], variables[2]), pow(variables[6], variables[18])); - variables[46] = or(lt(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])); - variables[47] = variables[1]/or(variables[2], variables[6]); - variables[48] = xor(variables[1], variables[2]); - variables[49] = xor(variables[1], xor(variables[2], variables[6])); - variables[50] = xor(lt(variables[1], variables[2]), gt(variables[6], variables[18])); - variables[51] = xor(variables[1]+variables[2], gt(variables[6], variables[18])); - variables[52] = xor(variables[1], gt(variables[2], variables[6])); - variables[53] = xor(variables[1]-variables[2], gt(variables[6], variables[18])); - variables[54] = xor(-variables[1], gt(variables[2], variables[6])); - variables[55] = xor(pow(variables[1], variables[2]), gt(variables[6], variables[18])); - variables[56] = xor(pow(variables[1], 1.0/variables[2]), gt(variables[6], variables[18])); - variables[57] = xor(lt(variables[1], variables[2]), variables[6]+variables[18]); - variables[58] = xor(lt(variables[1], variables[2]), variables[6]); - variables[59] = xor(lt(variables[1], variables[2]), variables[6]-variables[18]); - variables[60] = xor(lt(variables[1], variables[2]), -variables[6]); - variables[61] = xor(lt(variables[1], variables[2]), pow(variables[6], variables[18])); - variables[62] = xor(lt(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])); - variables[63] = variables[1]/xor(variables[2], variables[6]); - variables[64] = not(variables[1]); - variables[65] = variables[1]+variables[2]; - variables[66] = variables[1]+variables[2]+variables[6]; - variables[67] = lt(variables[1], variables[2])+gt(variables[6], variables[18]); - variables[68] = variables[1]; - variables[69] = variables[1]-variables[2]; - variables[70] = lt(variables[1], variables[2])-gt(variables[6], variables[18]); - variables[71] = lt(variables[1], variables[2])-(variables[6]+variables[18]); - variables[72] = lt(variables[1], variables[2])-variables[6]; - variables[73] = variables[1]-(-variables[2]); - variables[74] = variables[1]-(-variables[2]*variables[6]); - variables[75] = -variables[1]; - variables[76] = -lt(variables[1], variables[2]); - variables[77] = variables[1]*variables[2]; - variables[78] = variables[1]*variables[2]*variables[6]; - variables[79] = lt(variables[1], variables[2])*gt(variables[6], variables[18]); - variables[80] = (variables[1]+variables[2])*gt(variables[6], variables[18]); - variables[81] = variables[1]*gt(variables[2], variables[6]); - variables[82] = (variables[1]-variables[2])*gt(variables[6], variables[18]); - variables[83] = -variables[1]*gt(variables[2], variables[6]); - variables[84] = lt(variables[1], variables[2])*(variables[6]+variables[18]); - variables[85] = lt(variables[1], variables[2])*variables[6]; - variables[86] = lt(variables[1], variables[2])*(variables[6]-variables[18]); - variables[87] = lt(variables[1], variables[2])*-variables[6]; - variables[88] = variables[1]/variables[2]; - variables[89] = lt(variables[1], variables[2])/gt(variables[18], variables[6]); - variables[90] = (variables[1]+variables[2])/gt(variables[18], variables[6]); - variables[91] = variables[1]/gt(variables[6], variables[2]); - variables[92] = (variables[1]-variables[2])/gt(variables[18], variables[6]); - variables[93] = -variables[1]/gt(variables[6], variables[2]); - variables[94] = lt(variables[1], variables[2])/(variables[6]+variables[18]); - variables[95] = lt(variables[1], variables[2])/variables[6]; - variables[96] = lt(variables[1], variables[2])/(variables[6]-variables[18]); - variables[97] = lt(variables[1], variables[2])/-variables[6]; - variables[98] = lt(variables[1], variables[2])/(variables[6]*variables[18]); - variables[99] = lt(variables[1], variables[2])/(variables[6]/variables[18]); - variables[100] = sqrt(variables[1]); - variables[101] = pow(variables[1], 2.0); - variables[102] = pow(variables[1], 3.0); - variables[103] = pow(variables[1], variables[2]); - variables[104] = pow(leq(variables[1], variables[2]), geq(variables[6], variables[18])); - variables[105] = pow(variables[1]+variables[2], geq(variables[6], variables[18])); - variables[106] = pow(variables[1], geq(variables[2], variables[6])); - variables[107] = pow(variables[1]-variables[2], geq(variables[6], variables[18])); - variables[108] = pow(-variables[1], geq(variables[2], variables[6])); - variables[109] = pow(variables[1]*variables[2], geq(variables[6], variables[18])); - variables[110] = pow(variables[1]/variables[2], geq(variables[6], variables[18])); - variables[111] = pow(leq(variables[1], variables[2]), variables[6]+variables[18]); - variables[112] = pow(leq(variables[1], variables[2]), variables[6]); - variables[113] = pow(leq(variables[1], variables[2]), variables[6]-variables[18]); - variables[114] = pow(leq(variables[1], variables[2]), -variables[6]); - variables[115] = pow(leq(variables[1], variables[2]), variables[6]*variables[18]); - variables[116] = pow(leq(variables[1], variables[2]), variables[6]/variables[18]); - variables[117] = pow(leq(variables[1], variables[2]), pow(variables[6], variables[18])); - variables[118] = pow(leq(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])); - variables[119] = sqrt(variables[1]); - variables[120] = sqrt(variables[1]); - variables[121] = pow(variables[1], 1.0/3.0); - variables[122] = pow(variables[1], 1.0/variables[2]); - variables[123] = pow(lt(variables[1], variables[2]), 1.0/gt(variables[18], variables[6])); - variables[124] = pow(variables[1]+variables[2], 1.0/gt(variables[18], variables[6])); - variables[125] = pow(variables[1], 1.0/gt(variables[6], variables[2])); - variables[126] = pow(variables[1]-variables[2], 1.0/gt(variables[18], variables[6])); - variables[127] = pow(-variables[1], 1.0/gt(variables[6], variables[2])); - variables[128] = pow(variables[1]*variables[2], 1.0/gt(variables[18], variables[6])); - variables[129] = pow(variables[1]/variables[2], 1.0/gt(variables[18], variables[6])); - variables[130] = pow(lt(variables[1], variables[2]), 1.0/(variables[6]+variables[18])); - variables[131] = pow(lt(variables[1], variables[2]), 1.0/variables[6]); - variables[132] = pow(lt(variables[1], variables[2]), 1.0/(variables[6]-variables[18])); - variables[133] = pow(lt(variables[1], variables[2]), 1.0/-variables[6]); - variables[134] = pow(lt(variables[1], variables[2]), 1.0/(variables[6]*variables[18])); - variables[135] = pow(lt(variables[1], variables[2]), 1.0/(variables[6]/variables[18])); - variables[136] = pow(lt(variables[1], variables[2]), 1.0/pow(variables[6], variables[18])); - variables[137] = pow(lt(variables[1], variables[2]), 1.0/pow(variables[6], 1.0/variables[18])); - variables[138] = fabs(variables[1]); - variables[139] = exp(variables[1]); - variables[140] = log(variables[1]); - variables[141] = log10(variables[1]); - variables[142] = log(variables[1])/log(2.0); - variables[143] = log10(variables[1]); - variables[144] = log(variables[1])/log(variables[2]); - variables[145] = ceil(variables[1]); - variables[146] = floor(variables[1]); - variables[147] = min(variables[1], variables[2]); - variables[148] = min(variables[1], min(variables[2], variables[6])); - variables[149] = max(variables[1], variables[2]); - variables[150] = max(variables[1], max(variables[2], variables[6])); - variables[151] = fmod(variables[1], variables[2]); - variables[152] = sin(variables[1]); - variables[153] = cos(variables[1]); - variables[154] = tan(variables[1]); - variables[155] = sec(variables[1]); - variables[156] = csc(variables[1]); - variables[157] = cot(variables[1]); - variables[158] = sinh(variables[1]); - variables[159] = cosh(variables[1]); - variables[160] = tanh(variables[1]); - variables[161] = sech(variables[1]); - variables[162] = csch(variables[1]); - variables[163] = coth(variables[1]); - variables[164] = asin(variables[1]); - variables[165] = acos(variables[1]); - variables[166] = atan(variables[1]); - variables[167] = asec(variables[1]); - variables[168] = acsc(variables[1]); - variables[169] = acot(variables[1]); - variables[170] = asinh(variables[1]); - variables[171] = acosh(variables[1]); - variables[172] = atanh(variables[1]/2.0); - variables[173] = asech(variables[1]); - variables[174] = acsch(variables[1]); - variables[175] = acoth(2.0*variables[1]); - variables[176] = (gt(variables[1], variables[2]))?variables[1]:NAN; - variables[177] = (gt(variables[1], variables[2]))?variables[1]:variables[6]; - variables[178] = (gt(variables[1], variables[2]))?variables[1]:(gt(variables[6], variables[18]))?variables[6]:(gt(variables[179], variables[180]))?variables[179]:NAN; - variables[181] = (gt(variables[1], variables[2]))?variables[1]:(gt(variables[6], variables[18]))?variables[6]:(gt(variables[179], variables[180]))?variables[179]:variables[182]; - variables[183] = 123.0+((gt(variables[1], variables[2]))?variables[1]:NAN); - variables[188] = variables[1]; - variables[195] = and(variables[1], variables[2])+((gt(variables[6], variables[18]))?variables[2]:NAN)+variables[179]+and(variables[180], variables[182]); - variables[196] = and(variables[1], variables[2])-(((gt(variables[6], variables[18]))?variables[2]:NAN)-(variables[179]-((gt(variables[6], variables[18]))?variables[2]:NAN)))-and(variables[180], variables[182]); - variables[197] = and(variables[1], variables[2])*((gt(variables[6], variables[18]))?variables[2]:NAN)*variables[179]*((gt(variables[6], variables[18]))?variables[2]:NAN)*and(variables[180], variables[182]); - variables[198] = and(variables[1], variables[2])/(((gt(variables[6], variables[18]))?variables[2]:NAN)/(variables[179]/((gt(variables[6], variables[18]))?variables[2]:NAN))); - variables[199] = and(or(variables[1], variables[2]), and(xor(variables[1], variables[2]), and((gt(variables[6], variables[18]))?variables[2]:NAN, and(and(and(variables[179], (gt(variables[6], variables[18]))?variables[2]:NAN), xor(variables[1], variables[2])), or(variables[1], variables[2]))))); - variables[200] = or(and(variables[1], variables[2]), or(xor(variables[1], variables[2]), or((gt(variables[6], variables[18]))?variables[2]:NAN, or(or(or(variables[179], (gt(variables[6], variables[18]))?variables[2]:NAN), xor(variables[1], variables[2])), and(variables[1], variables[2]))))); - variables[201] = xor(and(variables[1], variables[2]), xor(or(variables[1], variables[2]), xor((gt(variables[6], variables[18]))?variables[2]:NAN, xor(xor(xor(variables[179], (gt(variables[6], variables[18]))?variables[2]:NAN), or(variables[1], variables[2])), and(variables[1], variables[2]))))); - variables[202] = pow(and(variables[1], variables[2]), pow((gt(variables[6], variables[18]))?variables[2]:NAN, pow(pow(variables[179], (gt(variables[6], variables[18]))?variables[2]:NAN), and(variables[1], variables[2])))); - variables[203] = pow(pow(pow(and(variables[1], variables[2]), 1.0/pow((gt(variables[6], variables[18]))?variables[2]:NAN, 1.0/variables[179])), 1.0/((gt(variables[6], variables[18]))?variables[2]:NAN)), 1.0/and(variables[1], variables[2])); - variables[204] = -and(variables[1], variables[2])+-((gt(variables[6], variables[18]))?variables[2]:NAN); + computedConstants[0] = eq(constants[1], constants[2]); + computedConstants[3] = constants[1]/eq(constants[2], constants[2]); + computedConstants[4] = neq(constants[1], constants[2]); + computedConstants[5] = constants[1]/neq(constants[2], constants[6]); + computedConstants[7] = lt(constants[1], constants[2]); + computedConstants[8] = constants[1]/lt(constants[2], constants[6]); + computedConstants[9] = leq(constants[1], constants[2]); + computedConstants[10] = constants[1]/leq(constants[2], constants[6]); + computedConstants[11] = gt(constants[1], constants[2]); + computedConstants[12] = constants[1]/gt(constants[2], constants[6]); + computedConstants[13] = geq(constants[1], constants[2]); + computedConstants[14] = constants[1]/geq(constants[2], constants[6]); + computedConstants[15] = and(constants[1], constants[2]); + computedConstants[16] = and(constants[1], and(constants[2], constants[6])); + computedConstants[17] = and(lt(constants[1], constants[2]), gt(constants[6], constants[18])); + computedConstants[19] = and(constants[1]+constants[2], gt(constants[6], constants[18])); + computedConstants[20] = and(constants[1], gt(constants[2], constants[6])); + computedConstants[21] = and(constants[1]-constants[2], gt(constants[6], constants[18])); + computedConstants[22] = and(-constants[1], gt(constants[2], constants[6])); + computedConstants[23] = and(pow(constants[1], constants[2]), gt(constants[6], constants[18])); + computedConstants[24] = and(pow(constants[1], 1.0/constants[2]), gt(constants[6], constants[18])); + computedConstants[25] = and(lt(constants[1], constants[2]), constants[6]+constants[18]); + computedConstants[26] = and(lt(constants[1], constants[2]), constants[6]); + computedConstants[27] = and(lt(constants[1], constants[2]), constants[6]-constants[18]); + computedConstants[28] = and(lt(constants[1], constants[2]), -constants[6]); + computedConstants[29] = and(lt(constants[1], constants[2]), pow(constants[6], constants[18])); + computedConstants[30] = and(lt(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])); + computedConstants[31] = constants[1]/and(constants[2], constants[6]); + computedConstants[32] = or(constants[1], constants[2]); + computedConstants[33] = or(constants[1], or(constants[2], constants[6])); + computedConstants[34] = or(lt(constants[1], constants[2]), gt(constants[6], constants[18])); + computedConstants[35] = or(constants[1]+constants[2], gt(constants[6], constants[18])); + computedConstants[36] = or(constants[1], gt(constants[2], constants[6])); + computedConstants[37] = or(constants[1]-constants[2], gt(constants[6], constants[18])); + computedConstants[38] = or(-constants[1], gt(constants[2], constants[6])); + computedConstants[39] = or(pow(constants[1], constants[2]), gt(constants[6], constants[18])); + computedConstants[40] = or(pow(constants[1], 1.0/constants[2]), gt(constants[6], constants[18])); + computedConstants[41] = or(lt(constants[1], constants[2]), constants[6]+constants[18]); + computedConstants[42] = or(lt(constants[1], constants[2]), constants[6]); + computedConstants[43] = or(lt(constants[1], constants[2]), constants[6]-constants[18]); + computedConstants[44] = or(lt(constants[1], constants[2]), -constants[6]); + computedConstants[45] = or(lt(constants[1], constants[2]), pow(constants[6], constants[18])); + computedConstants[46] = or(lt(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])); + computedConstants[47] = constants[1]/or(constants[2], constants[6]); + computedConstants[48] = xor(constants[1], constants[2]); + computedConstants[49] = xor(constants[1], xor(constants[2], constants[6])); + computedConstants[50] = xor(lt(constants[1], constants[2]), gt(constants[6], constants[18])); + computedConstants[51] = xor(constants[1]+constants[2], gt(constants[6], constants[18])); + computedConstants[52] = xor(constants[1], gt(constants[2], constants[6])); + computedConstants[53] = xor(constants[1]-constants[2], gt(constants[6], constants[18])); + computedConstants[54] = xor(-constants[1], gt(constants[2], constants[6])); + computedConstants[55] = xor(pow(constants[1], constants[2]), gt(constants[6], constants[18])); + computedConstants[56] = xor(pow(constants[1], 1.0/constants[2]), gt(constants[6], constants[18])); + computedConstants[57] = xor(lt(constants[1], constants[2]), constants[6]+constants[18]); + computedConstants[58] = xor(lt(constants[1], constants[2]), constants[6]); + computedConstants[59] = xor(lt(constants[1], constants[2]), constants[6]-constants[18]); + computedConstants[60] = xor(lt(constants[1], constants[2]), -constants[6]); + computedConstants[61] = xor(lt(constants[1], constants[2]), pow(constants[6], constants[18])); + computedConstants[62] = xor(lt(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])); + computedConstants[63] = constants[1]/xor(constants[2], constants[6]); + computedConstants[64] = not(constants[1]); + computedConstants[65] = constants[1]+constants[2]; + computedConstants[66] = constants[1]+constants[2]+constants[6]; + computedConstants[67] = lt(constants[1], constants[2])+gt(constants[6], constants[18]); + computedConstants[68] = constants[1]; + computedConstants[69] = constants[1]-constants[2]; + computedConstants[70] = lt(constants[1], constants[2])-gt(constants[6], constants[18]); + computedConstants[71] = lt(constants[1], constants[2])-(constants[6]+constants[18]); + computedConstants[72] = lt(constants[1], constants[2])-constants[6]; + computedConstants[73] = constants[1]-(-constants[2]); + computedConstants[74] = constants[1]-(-constants[2]*constants[6]); + computedConstants[75] = -constants[1]; + computedConstants[76] = -lt(constants[1], constants[2]); + computedConstants[77] = constants[1]*constants[2]; + computedConstants[78] = constants[1]*constants[2]*constants[6]; + computedConstants[79] = lt(constants[1], constants[2])*gt(constants[6], constants[18]); + computedConstants[80] = (constants[1]+constants[2])*gt(constants[6], constants[18]); + computedConstants[81] = constants[1]*gt(constants[2], constants[6]); + computedConstants[82] = (constants[1]-constants[2])*gt(constants[6], constants[18]); + computedConstants[83] = -constants[1]*gt(constants[2], constants[6]); + computedConstants[84] = lt(constants[1], constants[2])*(constants[6]+constants[18]); + computedConstants[85] = lt(constants[1], constants[2])*constants[6]; + computedConstants[86] = lt(constants[1], constants[2])*(constants[6]-constants[18]); + computedConstants[87] = lt(constants[1], constants[2])*-constants[6]; + computedConstants[88] = constants[1]/constants[2]; + computedConstants[89] = lt(constants[1], constants[2])/gt(constants[18], constants[6]); + computedConstants[90] = (constants[1]+constants[2])/gt(constants[18], constants[6]); + computedConstants[91] = constants[1]/gt(constants[6], constants[2]); + computedConstants[92] = (constants[1]-constants[2])/gt(constants[18], constants[6]); + computedConstants[93] = -constants[1]/gt(constants[6], constants[2]); + computedConstants[94] = lt(constants[1], constants[2])/(constants[6]+constants[18]); + computedConstants[95] = lt(constants[1], constants[2])/constants[6]; + computedConstants[96] = lt(constants[1], constants[2])/(constants[6]-constants[18]); + computedConstants[97] = lt(constants[1], constants[2])/-constants[6]; + computedConstants[98] = lt(constants[1], constants[2])/(constants[6]*constants[18]); + computedConstants[99] = lt(constants[1], constants[2])/(constants[6]/constants[18]); + computedConstants[100] = sqrt(constants[1]); + computedConstants[101] = pow(constants[1], 2.0); + computedConstants[102] = pow(constants[1], 3.0); + computedConstants[103] = pow(constants[1], constants[2]); + computedConstants[104] = pow(leq(constants[1], constants[2]), geq(constants[6], constants[18])); + computedConstants[105] = pow(constants[1]+constants[2], geq(constants[6], constants[18])); + computedConstants[106] = pow(constants[1], geq(constants[2], constants[6])); + computedConstants[107] = pow(constants[1]-constants[2], geq(constants[6], constants[18])); + computedConstants[108] = pow(-constants[1], geq(constants[2], constants[6])); + computedConstants[109] = pow(constants[1]*constants[2], geq(constants[6], constants[18])); + computedConstants[110] = pow(constants[1]/constants[2], geq(constants[6], constants[18])); + computedConstants[111] = pow(leq(constants[1], constants[2]), constants[6]+constants[18]); + computedConstants[112] = pow(leq(constants[1], constants[2]), constants[6]); + computedConstants[113] = pow(leq(constants[1], constants[2]), constants[6]-constants[18]); + computedConstants[114] = pow(leq(constants[1], constants[2]), -constants[6]); + computedConstants[115] = pow(leq(constants[1], constants[2]), constants[6]*constants[18]); + computedConstants[116] = pow(leq(constants[1], constants[2]), constants[6]/constants[18]); + computedConstants[117] = pow(leq(constants[1], constants[2]), pow(constants[6], constants[18])); + computedConstants[118] = pow(leq(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])); + computedConstants[119] = sqrt(constants[1]); + computedConstants[120] = sqrt(constants[1]); + computedConstants[121] = pow(constants[1], 1.0/3.0); + computedConstants[122] = pow(constants[1], 1.0/constants[2]); + computedConstants[123] = pow(lt(constants[1], constants[2]), 1.0/gt(constants[18], constants[6])); + computedConstants[124] = pow(constants[1]+constants[2], 1.0/gt(constants[18], constants[6])); + computedConstants[125] = pow(constants[1], 1.0/gt(constants[6], constants[2])); + computedConstants[126] = pow(constants[1]-constants[2], 1.0/gt(constants[18], constants[6])); + computedConstants[127] = pow(-constants[1], 1.0/gt(constants[6], constants[2])); + computedConstants[128] = pow(constants[1]*constants[2], 1.0/gt(constants[18], constants[6])); + computedConstants[129] = pow(constants[1]/constants[2], 1.0/gt(constants[18], constants[6])); + computedConstants[130] = pow(lt(constants[1], constants[2]), 1.0/(constants[6]+constants[18])); + computedConstants[131] = pow(lt(constants[1], constants[2]), 1.0/constants[6]); + computedConstants[132] = pow(lt(constants[1], constants[2]), 1.0/(constants[6]-constants[18])); + computedConstants[133] = pow(lt(constants[1], constants[2]), 1.0/-constants[6]); + computedConstants[134] = pow(lt(constants[1], constants[2]), 1.0/(constants[6]*constants[18])); + computedConstants[135] = pow(lt(constants[1], constants[2]), 1.0/(constants[6]/constants[18])); + computedConstants[136] = pow(lt(constants[1], constants[2]), 1.0/pow(constants[6], constants[18])); + computedConstants[137] = pow(lt(constants[1], constants[2]), 1.0/pow(constants[6], 1.0/constants[18])); + computedConstants[138] = fabs(constants[1]); + computedConstants[139] = exp(constants[1]); + computedConstants[140] = log(constants[1]); + computedConstants[141] = log10(constants[1]); + computedConstants[142] = log(constants[1])/log(2.0); + computedConstants[143] = log10(constants[1]); + computedConstants[144] = log(constants[1])/log(constants[2]); + computedConstants[145] = ceil(constants[1]); + computedConstants[146] = floor(constants[1]); + computedConstants[147] = min(constants[1], constants[2]); + computedConstants[148] = min(constants[1], min(constants[2], constants[6])); + computedConstants[149] = max(constants[1], constants[2]); + computedConstants[150] = max(constants[1], max(constants[2], constants[6])); + computedConstants[151] = fmod(constants[1], constants[2]); + computedConstants[152] = sin(constants[1]); + computedConstants[153] = cos(constants[1]); + computedConstants[154] = tan(constants[1]); + computedConstants[155] = sec(constants[1]); + computedConstants[156] = csc(constants[1]); + computedConstants[157] = cot(constants[1]); + computedConstants[158] = sinh(constants[1]); + computedConstants[159] = cosh(constants[1]); + computedConstants[160] = tanh(constants[1]); + computedConstants[161] = sech(constants[1]); + computedConstants[162] = csch(constants[1]); + computedConstants[163] = coth(constants[1]); + computedConstants[164] = asin(constants[1]); + computedConstants[165] = acos(constants[1]); + computedConstants[166] = atan(constants[1]); + computedConstants[167] = asec(constants[1]); + computedConstants[168] = acsc(constants[1]); + computedConstants[169] = acot(constants[1]); + computedConstants[170] = asinh(constants[1]); + computedConstants[171] = acosh(constants[1]); + computedConstants[172] = atanh(constants[1]/2.0); + computedConstants[173] = asech(constants[1]); + computedConstants[174] = acsch(constants[1]); + computedConstants[175] = acoth(2.0*constants[1]); + computedConstants[176] = (gt(constants[1], constants[2]))?constants[1]:NAN; + computedConstants[177] = (gt(constants[1], constants[2]))?constants[1]:constants[6]; + computedConstants[178] = (gt(constants[1], constants[2]))?constants[1]:(gt(constants[6], constants[18]))?constants[6]:(gt(constants[179], constants[180]))?constants[179]:NAN; + computedConstants[181] = (gt(constants[1], constants[2]))?constants[1]:(gt(constants[6], constants[18]))?constants[6]:(gt(constants[179], constants[180]))?constants[179]:constants[182]; + computedConstants[183] = 123.0+((gt(constants[1], constants[2]))?constants[1]:NAN); + computedConstants[188] = constants[1]; + computedConstants[195] = and(constants[1], constants[2])+((gt(constants[6], constants[18]))?constants[2]:NAN)+constants[179]+and(constants[180], constants[182]); + computedConstants[196] = and(constants[1], constants[2])-(((gt(constants[6], constants[18]))?constants[2]:NAN)-(constants[179]-((gt(constants[6], constants[18]))?constants[2]:NAN)))-and(constants[180], constants[182]); + computedConstants[197] = and(constants[1], constants[2])*((gt(constants[6], constants[18]))?constants[2]:NAN)*constants[179]*((gt(constants[6], constants[18]))?constants[2]:NAN)*and(constants[180], constants[182]); + computedConstants[198] = and(constants[1], constants[2])/(((gt(constants[6], constants[18]))?constants[2]:NAN)/(constants[179]/((gt(constants[6], constants[18]))?constants[2]:NAN))); + computedConstants[199] = and(or(constants[1], constants[2]), and(xor(constants[1], constants[2]), and((gt(constants[6], constants[18]))?constants[2]:NAN, and(and(and(constants[179], (gt(constants[6], constants[18]))?constants[2]:NAN), xor(constants[1], constants[2])), or(constants[1], constants[2]))))); + computedConstants[200] = or(and(constants[1], constants[2]), or(xor(constants[1], constants[2]), or((gt(constants[6], constants[18]))?constants[2]:NAN, or(or(or(constants[179], (gt(constants[6], constants[18]))?constants[2]:NAN), xor(constants[1], constants[2])), and(constants[1], constants[2]))))); + computedConstants[201] = xor(and(constants[1], constants[2]), xor(or(constants[1], constants[2]), xor((gt(constants[6], constants[18]))?constants[2]:NAN, xor(xor(xor(constants[179], (gt(constants[6], constants[18]))?constants[2]:NAN), or(constants[1], constants[2])), and(constants[1], constants[2]))))); + computedConstants[202] = pow(and(constants[1], constants[2]), pow((gt(constants[6], constants[18]))?constants[2]:NAN, pow(pow(constants[179], (gt(constants[6], constants[18]))?constants[2]:NAN), and(constants[1], constants[2])))); + computedConstants[203] = pow(pow(pow(and(constants[1], constants[2]), 1.0/pow((gt(constants[6], constants[18]))?constants[2]:NAN, 1.0/constants[179])), 1.0/((gt(constants[6], constants[18]))?constants[2]:NAN)), 1.0/and(constants[1], constants[2])); + computedConstants[204] = -and(constants[1], constants[2])+-((gt(constants[6], constants[18]))?constants[2]:NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index b86a172b9..b5bd90746 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -356,11 +356,11 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[205] = u[0]; - variables[206] = u[1]; + algebraic[205] = u[0]; + algebraic[206] = u[1]; - f[0] = variables[205]+variables[206]+states[0]-0.0; - f[1] = variables[205]-variables[206]-(variables[207]+variables[208]); + f[0] = algebraic[205]+algebraic[206]+states[0]-0.0; + f[1] = algebraic[205]-algebraic[206]-(computedConstants[207]+computedConstants[208]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -368,231 +368,231 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[2]; - u[0] = variables[205]; - u[1] = variables[206]; + u[0] = algebraic[205]; + u[1] = algebraic[206]; nlaSolve(objectiveFunction0, u, 2, &rfi); - variables[205] = u[0]; - variables[206] = u[1]; + algebraic[205] = u[0]; + algebraic[206] = u[1]; } void initialiseVariables(double *states, double *rates, double *constants) { - variables[1] = 1.0; - variables[2] = 2.0; - variables[6] = 3.0; - variables[18] = 4.0; - variables[179] = 5.0; - variables[180] = 6.0; - variables[182] = 7.0; - variables[205] = 1.0; - variables[206] = 2.0; - variables[184] = 123.0; - variables[185] = 123.456789; - variables[186] = 123.0e99; - variables[187] = 123.456789e99; - variables[189] = 1.0; - variables[190] = 0.0; - variables[191] = 2.71828182845905; - variables[192] = 3.14159265358979; - variables[193] = INFINITY; - variables[194] = NAN; - variables[207] = 1.0; - variables[208] = 3.0; + constants[1] = 1.0; + constants[2] = 2.0; + constants[6] = 3.0; + constants[18] = 4.0; + constants[179] = 5.0; + constants[180] = 6.0; + constants[182] = 7.0; + algebraic[205] = 1.0; + algebraic[206] = 2.0; + computedConstants[184] = 123.0; + computedConstants[185] = 123.456789; + computedConstants[186] = 123.0e99; + computedConstants[187] = 123.456789e99; + computedConstants[189] = 1.0; + computedConstants[190] = 0.0; + computedConstants[191] = 2.71828182845905; + computedConstants[192] = 3.14159265358979; + computedConstants[193] = INFINITY; + computedConstants[194] = NAN; + computedConstants[207] = 1.0; + computedConstants[208] = 3.0; states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { - variables[0] = variables[1] == variables[2]; - variables[3] = variables[1]/(variables[2] == variables[2]); - variables[4] = variables[1] != variables[2]; - variables[5] = variables[1]/(variables[2] != variables[6]); - variables[7] = variables[1] < variables[2]; - variables[8] = variables[1]/(variables[2] < variables[6]); - variables[9] = variables[1] <= variables[2]; - variables[10] = variables[1]/(variables[2] <= variables[6]); - variables[11] = variables[1] > variables[2]; - variables[12] = variables[1]/(variables[2] > variables[6]); - variables[13] = variables[1] >= variables[2]; - variables[14] = variables[1]/(variables[2] >= variables[6]); - variables[15] = variables[1] && variables[2]; - variables[16] = variables[1] && variables[2] && variables[6]; - variables[17] = (variables[1] < variables[2]) && (variables[6] > variables[18]); - variables[19] = (variables[1]+variables[2]) && (variables[6] > variables[18]); - variables[20] = variables[1] && (variables[2] > variables[6]); - variables[21] = (variables[1]-variables[2]) && (variables[6] > variables[18]); - variables[22] = -variables[1] && (variables[2] > variables[6]); - variables[23] = pow(variables[1], variables[2]) && (variables[6] > variables[18]); - variables[24] = pow(variables[1], 1.0/variables[2]) && (variables[6] > variables[18]); - variables[25] = (variables[1] < variables[2]) && (variables[6]+variables[18]); - variables[26] = (variables[1] < variables[2]) && variables[6]; - variables[27] = (variables[1] < variables[2]) && (variables[6]-variables[18]); - variables[28] = (variables[1] < variables[2]) && -variables[6]; - variables[29] = (variables[1] < variables[2]) && pow(variables[6], variables[18]); - variables[30] = (variables[1] < variables[2]) && pow(variables[6], 1.0/variables[18]); - variables[31] = variables[1]/(variables[2] && variables[6]); - variables[32] = variables[1] || variables[2]; - variables[33] = variables[1] || variables[2] || variables[6]; - variables[34] = (variables[1] < variables[2]) || (variables[6] > variables[18]); - variables[35] = (variables[1]+variables[2]) || (variables[6] > variables[18]); - variables[36] = variables[1] || (variables[2] > variables[6]); - variables[37] = (variables[1]-variables[2]) || (variables[6] > variables[18]); - variables[38] = -variables[1] || (variables[2] > variables[6]); - variables[39] = pow(variables[1], variables[2]) || (variables[6] > variables[18]); - variables[40] = pow(variables[1], 1.0/variables[2]) || (variables[6] > variables[18]); - variables[41] = (variables[1] < variables[2]) || (variables[6]+variables[18]); - variables[42] = (variables[1] < variables[2]) || variables[6]; - variables[43] = (variables[1] < variables[2]) || (variables[6]-variables[18]); - variables[44] = (variables[1] < variables[2]) || -variables[6]; - variables[45] = (variables[1] < variables[2]) || pow(variables[6], variables[18]); - variables[46] = (variables[1] < variables[2]) || pow(variables[6], 1.0/variables[18]); - variables[47] = variables[1]/(variables[2] || variables[6]); - variables[48] = xor(variables[1], variables[2]); - variables[49] = xor(variables[1], xor(variables[2], variables[6])); - variables[50] = xor(variables[1] < variables[2], variables[6] > variables[18]); - variables[51] = xor(variables[1]+variables[2], variables[6] > variables[18]); - variables[52] = xor(variables[1], variables[2] > variables[6]); - variables[53] = xor(variables[1]-variables[2], variables[6] > variables[18]); - variables[54] = xor(-variables[1], variables[2] > variables[6]); - variables[55] = xor(pow(variables[1], variables[2]), variables[6] > variables[18]); - variables[56] = xor(pow(variables[1], 1.0/variables[2]), variables[6] > variables[18]); - variables[57] = xor(variables[1] < variables[2], variables[6]+variables[18]); - variables[58] = xor(variables[1] < variables[2], variables[6]); - variables[59] = xor(variables[1] < variables[2], variables[6]-variables[18]); - variables[60] = xor(variables[1] < variables[2], -variables[6]); - variables[61] = xor(variables[1] < variables[2], pow(variables[6], variables[18])); - variables[62] = xor(variables[1] < variables[2], pow(variables[6], 1.0/variables[18])); - variables[63] = variables[1]/xor(variables[2], variables[6]); - variables[64] = !variables[1]; - variables[65] = variables[1]+variables[2]; - variables[66] = variables[1]+variables[2]+variables[6]; - variables[67] = (variables[1] < variables[2])+(variables[6] > variables[18]); - variables[68] = variables[1]; - variables[69] = variables[1]-variables[2]; - variables[70] = (variables[1] < variables[2])-(variables[6] > variables[18]); - variables[71] = (variables[1] < variables[2])-(variables[6]+variables[18]); - variables[72] = (variables[1] < variables[2])-variables[6]; - variables[73] = variables[1]-(-variables[2]); - variables[74] = variables[1]-(-variables[2]*variables[6]); - variables[75] = -variables[1]; - variables[76] = -(variables[1] < variables[2]); - variables[77] = variables[1]*variables[2]; - variables[78] = variables[1]*variables[2]*variables[6]; - variables[79] = (variables[1] < variables[2])*(variables[6] > variables[18]); - variables[80] = (variables[1]+variables[2])*(variables[6] > variables[18]); - variables[81] = variables[1]*(variables[2] > variables[6]); - variables[82] = (variables[1]-variables[2])*(variables[6] > variables[18]); - variables[83] = -variables[1]*(variables[2] > variables[6]); - variables[84] = (variables[1] < variables[2])*(variables[6]+variables[18]); - variables[85] = (variables[1] < variables[2])*variables[6]; - variables[86] = (variables[1] < variables[2])*(variables[6]-variables[18]); - variables[87] = (variables[1] < variables[2])*-variables[6]; - variables[88] = variables[1]/variables[2]; - variables[89] = (variables[1] < variables[2])/(variables[18] > variables[6]); - variables[90] = (variables[1]+variables[2])/(variables[18] > variables[6]); - variables[91] = variables[1]/(variables[6] > variables[2]); - variables[92] = (variables[1]-variables[2])/(variables[18] > variables[6]); - variables[93] = -variables[1]/(variables[6] > variables[2]); - variables[94] = (variables[1] < variables[2])/(variables[6]+variables[18]); - variables[95] = (variables[1] < variables[2])/variables[6]; - variables[96] = (variables[1] < variables[2])/(variables[6]-variables[18]); - variables[97] = (variables[1] < variables[2])/-variables[6]; - variables[98] = (variables[1] < variables[2])/(variables[6]*variables[18]); - variables[99] = (variables[1] < variables[2])/(variables[6]/variables[18]); - variables[100] = sqrt(variables[1]); - variables[101] = pow(variables[1], 2.0); - variables[102] = pow(variables[1], 3.0); - variables[103] = pow(variables[1], variables[2]); - variables[104] = pow(variables[1] <= variables[2], variables[6] >= variables[18]); - variables[105] = pow(variables[1]+variables[2], variables[6] >= variables[18]); - variables[106] = pow(variables[1], variables[2] >= variables[6]); - variables[107] = pow(variables[1]-variables[2], variables[6] >= variables[18]); - variables[108] = pow(-variables[1], variables[2] >= variables[6]); - variables[109] = pow(variables[1]*variables[2], variables[6] >= variables[18]); - variables[110] = pow(variables[1]/variables[2], variables[6] >= variables[18]); - variables[111] = pow(variables[1] <= variables[2], variables[6]+variables[18]); - variables[112] = pow(variables[1] <= variables[2], variables[6]); - variables[113] = pow(variables[1] <= variables[2], variables[6]-variables[18]); - variables[114] = pow(variables[1] <= variables[2], -variables[6]); - variables[115] = pow(variables[1] <= variables[2], variables[6]*variables[18]); - variables[116] = pow(variables[1] <= variables[2], variables[6]/variables[18]); - variables[117] = pow(variables[1] <= variables[2], pow(variables[6], variables[18])); - variables[118] = pow(variables[1] <= variables[2], pow(variables[6], 1.0/variables[18])); - variables[119] = sqrt(variables[1]); - variables[120] = sqrt(variables[1]); - variables[121] = pow(variables[1], 1.0/3.0); - variables[122] = pow(variables[1], 1.0/variables[2]); - variables[123] = pow(variables[1] < variables[2], 1.0/(variables[18] > variables[6])); - variables[124] = pow(variables[1]+variables[2], 1.0/(variables[18] > variables[6])); - variables[125] = pow(variables[1], 1.0/(variables[6] > variables[2])); - variables[126] = pow(variables[1]-variables[2], 1.0/(variables[18] > variables[6])); - variables[127] = pow(-variables[1], 1.0/(variables[6] > variables[2])); - variables[128] = pow(variables[1]*variables[2], 1.0/(variables[18] > variables[6])); - variables[129] = pow(variables[1]/variables[2], 1.0/(variables[18] > variables[6])); - variables[130] = pow(variables[1] < variables[2], 1.0/(variables[6]+variables[18])); - variables[131] = pow(variables[1] < variables[2], 1.0/variables[6]); - variables[132] = pow(variables[1] < variables[2], 1.0/(variables[6]-variables[18])); - variables[133] = pow(variables[1] < variables[2], 1.0/-variables[6]); - variables[134] = pow(variables[1] < variables[2], 1.0/(variables[6]*variables[18])); - variables[135] = pow(variables[1] < variables[2], 1.0/(variables[6]/variables[18])); - variables[136] = pow(variables[1] < variables[2], 1.0/pow(variables[6], variables[18])); - variables[137] = pow(variables[1] < variables[2], 1.0/pow(variables[6], 1.0/variables[18])); - variables[138] = fabs(variables[1]); - variables[139] = exp(variables[1]); - variables[140] = log(variables[1]); - variables[141] = log10(variables[1]); - variables[142] = log(variables[1])/log(2.0); - variables[143] = log10(variables[1]); - variables[144] = log(variables[1])/log(variables[2]); - variables[145] = ceil(variables[1]); - variables[146] = floor(variables[1]); - variables[147] = min(variables[1], variables[2]); - variables[148] = min(variables[1], min(variables[2], variables[6])); - variables[149] = max(variables[1], variables[2]); - variables[150] = max(variables[1], max(variables[2], variables[6])); - variables[151] = fmod(variables[1], variables[2]); - variables[152] = sin(variables[1]); - variables[153] = cos(variables[1]); - variables[154] = tan(variables[1]); - variables[155] = sec(variables[1]); - variables[156] = csc(variables[1]); - variables[157] = cot(variables[1]); - variables[158] = sinh(variables[1]); - variables[159] = cosh(variables[1]); - variables[160] = tanh(variables[1]); - variables[161] = sech(variables[1]); - variables[162] = csch(variables[1]); - variables[163] = coth(variables[1]); - variables[164] = asin(variables[1]); - variables[165] = acos(variables[1]); - variables[166] = atan(variables[1]); - variables[167] = asec(variables[1]); - variables[168] = acsc(variables[1]); - variables[169] = acot(variables[1]); - variables[170] = asinh(variables[1]); - variables[171] = acosh(variables[1]); - variables[172] = atanh(variables[1]/2.0); - variables[173] = asech(variables[1]); - variables[174] = acsch(variables[1]); - variables[175] = acoth(2.0*variables[1]); - variables[176] = (variables[1] > variables[2])?variables[1]:NAN; - variables[177] = (variables[1] > variables[2])?variables[1]:variables[6]; - variables[178] = (variables[1] > variables[2])?variables[1]:(variables[6] > variables[18])?variables[6]:(variables[179] > variables[180])?variables[179]:NAN; - variables[181] = (variables[1] > variables[2])?variables[1]:(variables[6] > variables[18])?variables[6]:(variables[179] > variables[180])?variables[179]:variables[182]; - variables[183] = 123.0+((variables[1] > variables[2])?variables[1]:NAN); - variables[188] = variables[1]; - variables[195] = (variables[1] && variables[2])+((variables[6] > variables[18])?variables[2]:NAN)+variables[179]+(variables[180] && variables[182]); - variables[196] = (variables[1] && variables[2])-(((variables[6] > variables[18])?variables[2]:NAN)-(variables[179]-((variables[6] > variables[18])?variables[2]:NAN)))-(variables[180] && variables[182]); - variables[197] = (variables[1] && variables[2])*((variables[6] > variables[18])?variables[2]:NAN)*variables[179]*((variables[6] > variables[18])?variables[2]:NAN)*(variables[180] && variables[182]); - variables[198] = (variables[1] && variables[2])/(((variables[6] > variables[18])?variables[2]:NAN)/(variables[179]/((variables[6] > variables[18])?variables[2]:NAN))); - variables[199] = (variables[1] || variables[2]) && xor(variables[1], variables[2]) && ((variables[6] > variables[18])?variables[2]:NAN) && variables[179] && ((variables[6] > variables[18])?variables[2]:NAN) && xor(variables[1], variables[2]) && (variables[1] || variables[2]); - variables[200] = (variables[1] && variables[2]) || xor(variables[1], variables[2]) || ((variables[6] > variables[18])?variables[2]:NAN) || variables[179] || ((variables[6] > variables[18])?variables[2]:NAN) || xor(variables[1], variables[2]) || (variables[1] && variables[2]); - variables[201] = xor(variables[1] && variables[2], xor(variables[1] || variables[2], xor((variables[6] > variables[18])?variables[2]:NAN, xor(xor(xor(variables[179], (variables[6] > variables[18])?variables[2]:NAN), variables[1] || variables[2]), variables[1] && variables[2])))); - variables[202] = pow(variables[1] && variables[2], pow((variables[6] > variables[18])?variables[2]:NAN, pow(pow(variables[179], (variables[6] > variables[18])?variables[2]:NAN), variables[1] && variables[2]))); - variables[203] = pow(pow(pow(variables[1] && variables[2], 1.0/pow((variables[6] > variables[18])?variables[2]:NAN, 1.0/variables[179])), 1.0/((variables[6] > variables[18])?variables[2]:NAN)), 1.0/(variables[1] && variables[2])); - variables[204] = -(variables[1] && variables[2])+-((variables[6] > variables[18])?variables[2]:NAN); + computedConstants[0] = constants[1] == constants[2]; + computedConstants[3] = constants[1]/(constants[2] == constants[2]); + computedConstants[4] = constants[1] != constants[2]; + computedConstants[5] = constants[1]/(constants[2] != constants[6]); + computedConstants[7] = constants[1] < constants[2]; + computedConstants[8] = constants[1]/(constants[2] < constants[6]); + computedConstants[9] = constants[1] <= constants[2]; + computedConstants[10] = constants[1]/(constants[2] <= constants[6]); + computedConstants[11] = constants[1] > constants[2]; + computedConstants[12] = constants[1]/(constants[2] > constants[6]); + computedConstants[13] = constants[1] >= constants[2]; + computedConstants[14] = constants[1]/(constants[2] >= constants[6]); + computedConstants[15] = constants[1] && constants[2]; + computedConstants[16] = constants[1] && constants[2] && constants[6]; + computedConstants[17] = (constants[1] < constants[2]) && (constants[6] > constants[18]); + computedConstants[19] = (constants[1]+constants[2]) && (constants[6] > constants[18]); + computedConstants[20] = constants[1] && (constants[2] > constants[6]); + computedConstants[21] = (constants[1]-constants[2]) && (constants[6] > constants[18]); + computedConstants[22] = -constants[1] && (constants[2] > constants[6]); + computedConstants[23] = pow(constants[1], constants[2]) && (constants[6] > constants[18]); + computedConstants[24] = pow(constants[1], 1.0/constants[2]) && (constants[6] > constants[18]); + computedConstants[25] = (constants[1] < constants[2]) && (constants[6]+constants[18]); + computedConstants[26] = (constants[1] < constants[2]) && constants[6]; + computedConstants[27] = (constants[1] < constants[2]) && (constants[6]-constants[18]); + computedConstants[28] = (constants[1] < constants[2]) && -constants[6]; + computedConstants[29] = (constants[1] < constants[2]) && pow(constants[6], constants[18]); + computedConstants[30] = (constants[1] < constants[2]) && pow(constants[6], 1.0/constants[18]); + computedConstants[31] = constants[1]/(constants[2] && constants[6]); + computedConstants[32] = constants[1] || constants[2]; + computedConstants[33] = constants[1] || constants[2] || constants[6]; + computedConstants[34] = (constants[1] < constants[2]) || (constants[6] > constants[18]); + computedConstants[35] = (constants[1]+constants[2]) || (constants[6] > constants[18]); + computedConstants[36] = constants[1] || (constants[2] > constants[6]); + computedConstants[37] = (constants[1]-constants[2]) || (constants[6] > constants[18]); + computedConstants[38] = -constants[1] || (constants[2] > constants[6]); + computedConstants[39] = pow(constants[1], constants[2]) || (constants[6] > constants[18]); + computedConstants[40] = pow(constants[1], 1.0/constants[2]) || (constants[6] > constants[18]); + computedConstants[41] = (constants[1] < constants[2]) || (constants[6]+constants[18]); + computedConstants[42] = (constants[1] < constants[2]) || constants[6]; + computedConstants[43] = (constants[1] < constants[2]) || (constants[6]-constants[18]); + computedConstants[44] = (constants[1] < constants[2]) || -constants[6]; + computedConstants[45] = (constants[1] < constants[2]) || pow(constants[6], constants[18]); + computedConstants[46] = (constants[1] < constants[2]) || pow(constants[6], 1.0/constants[18]); + computedConstants[47] = constants[1]/(constants[2] || constants[6]); + computedConstants[48] = xor(constants[1], constants[2]); + computedConstants[49] = xor(constants[1], xor(constants[2], constants[6])); + computedConstants[50] = xor(constants[1] < constants[2], constants[6] > constants[18]); + computedConstants[51] = xor(constants[1]+constants[2], constants[6] > constants[18]); + computedConstants[52] = xor(constants[1], constants[2] > constants[6]); + computedConstants[53] = xor(constants[1]-constants[2], constants[6] > constants[18]); + computedConstants[54] = xor(-constants[1], constants[2] > constants[6]); + computedConstants[55] = xor(pow(constants[1], constants[2]), constants[6] > constants[18]); + computedConstants[56] = xor(pow(constants[1], 1.0/constants[2]), constants[6] > constants[18]); + computedConstants[57] = xor(constants[1] < constants[2], constants[6]+constants[18]); + computedConstants[58] = xor(constants[1] < constants[2], constants[6]); + computedConstants[59] = xor(constants[1] < constants[2], constants[6]-constants[18]); + computedConstants[60] = xor(constants[1] < constants[2], -constants[6]); + computedConstants[61] = xor(constants[1] < constants[2], pow(constants[6], constants[18])); + computedConstants[62] = xor(constants[1] < constants[2], pow(constants[6], 1.0/constants[18])); + computedConstants[63] = constants[1]/xor(constants[2], constants[6]); + computedConstants[64] = !constants[1]; + computedConstants[65] = constants[1]+constants[2]; + computedConstants[66] = constants[1]+constants[2]+constants[6]; + computedConstants[67] = (constants[1] < constants[2])+(constants[6] > constants[18]); + computedConstants[68] = constants[1]; + computedConstants[69] = constants[1]-constants[2]; + computedConstants[70] = (constants[1] < constants[2])-(constants[6] > constants[18]); + computedConstants[71] = (constants[1] < constants[2])-(constants[6]+constants[18]); + computedConstants[72] = (constants[1] < constants[2])-constants[6]; + computedConstants[73] = constants[1]-(-constants[2]); + computedConstants[74] = constants[1]-(-constants[2]*constants[6]); + computedConstants[75] = -constants[1]; + computedConstants[76] = -(constants[1] < constants[2]); + computedConstants[77] = constants[1]*constants[2]; + computedConstants[78] = constants[1]*constants[2]*constants[6]; + computedConstants[79] = (constants[1] < constants[2])*(constants[6] > constants[18]); + computedConstants[80] = (constants[1]+constants[2])*(constants[6] > constants[18]); + computedConstants[81] = constants[1]*(constants[2] > constants[6]); + computedConstants[82] = (constants[1]-constants[2])*(constants[6] > constants[18]); + computedConstants[83] = -constants[1]*(constants[2] > constants[6]); + computedConstants[84] = (constants[1] < constants[2])*(constants[6]+constants[18]); + computedConstants[85] = (constants[1] < constants[2])*constants[6]; + computedConstants[86] = (constants[1] < constants[2])*(constants[6]-constants[18]); + computedConstants[87] = (constants[1] < constants[2])*-constants[6]; + computedConstants[88] = constants[1]/constants[2]; + computedConstants[89] = (constants[1] < constants[2])/(constants[18] > constants[6]); + computedConstants[90] = (constants[1]+constants[2])/(constants[18] > constants[6]); + computedConstants[91] = constants[1]/(constants[6] > constants[2]); + computedConstants[92] = (constants[1]-constants[2])/(constants[18] > constants[6]); + computedConstants[93] = -constants[1]/(constants[6] > constants[2]); + computedConstants[94] = (constants[1] < constants[2])/(constants[6]+constants[18]); + computedConstants[95] = (constants[1] < constants[2])/constants[6]; + computedConstants[96] = (constants[1] < constants[2])/(constants[6]-constants[18]); + computedConstants[97] = (constants[1] < constants[2])/-constants[6]; + computedConstants[98] = (constants[1] < constants[2])/(constants[6]*constants[18]); + computedConstants[99] = (constants[1] < constants[2])/(constants[6]/constants[18]); + computedConstants[100] = sqrt(constants[1]); + computedConstants[101] = pow(constants[1], 2.0); + computedConstants[102] = pow(constants[1], 3.0); + computedConstants[103] = pow(constants[1], constants[2]); + computedConstants[104] = pow(constants[1] <= constants[2], constants[6] >= constants[18]); + computedConstants[105] = pow(constants[1]+constants[2], constants[6] >= constants[18]); + computedConstants[106] = pow(constants[1], constants[2] >= constants[6]); + computedConstants[107] = pow(constants[1]-constants[2], constants[6] >= constants[18]); + computedConstants[108] = pow(-constants[1], constants[2] >= constants[6]); + computedConstants[109] = pow(constants[1]*constants[2], constants[6] >= constants[18]); + computedConstants[110] = pow(constants[1]/constants[2], constants[6] >= constants[18]); + computedConstants[111] = pow(constants[1] <= constants[2], constants[6]+constants[18]); + computedConstants[112] = pow(constants[1] <= constants[2], constants[6]); + computedConstants[113] = pow(constants[1] <= constants[2], constants[6]-constants[18]); + computedConstants[114] = pow(constants[1] <= constants[2], -constants[6]); + computedConstants[115] = pow(constants[1] <= constants[2], constants[6]*constants[18]); + computedConstants[116] = pow(constants[1] <= constants[2], constants[6]/constants[18]); + computedConstants[117] = pow(constants[1] <= constants[2], pow(constants[6], constants[18])); + computedConstants[118] = pow(constants[1] <= constants[2], pow(constants[6], 1.0/constants[18])); + computedConstants[119] = sqrt(constants[1]); + computedConstants[120] = sqrt(constants[1]); + computedConstants[121] = pow(constants[1], 1.0/3.0); + computedConstants[122] = pow(constants[1], 1.0/constants[2]); + computedConstants[123] = pow(constants[1] < constants[2], 1.0/(constants[18] > constants[6])); + computedConstants[124] = pow(constants[1]+constants[2], 1.0/(constants[18] > constants[6])); + computedConstants[125] = pow(constants[1], 1.0/(constants[6] > constants[2])); + computedConstants[126] = pow(constants[1]-constants[2], 1.0/(constants[18] > constants[6])); + computedConstants[127] = pow(-constants[1], 1.0/(constants[6] > constants[2])); + computedConstants[128] = pow(constants[1]*constants[2], 1.0/(constants[18] > constants[6])); + computedConstants[129] = pow(constants[1]/constants[2], 1.0/(constants[18] > constants[6])); + computedConstants[130] = pow(constants[1] < constants[2], 1.0/(constants[6]+constants[18])); + computedConstants[131] = pow(constants[1] < constants[2], 1.0/constants[6]); + computedConstants[132] = pow(constants[1] < constants[2], 1.0/(constants[6]-constants[18])); + computedConstants[133] = pow(constants[1] < constants[2], 1.0/-constants[6]); + computedConstants[134] = pow(constants[1] < constants[2], 1.0/(constants[6]*constants[18])); + computedConstants[135] = pow(constants[1] < constants[2], 1.0/(constants[6]/constants[18])); + computedConstants[136] = pow(constants[1] < constants[2], 1.0/pow(constants[6], constants[18])); + computedConstants[137] = pow(constants[1] < constants[2], 1.0/pow(constants[6], 1.0/constants[18])); + computedConstants[138] = fabs(constants[1]); + computedConstants[139] = exp(constants[1]); + computedConstants[140] = log(constants[1]); + computedConstants[141] = log10(constants[1]); + computedConstants[142] = log(constants[1])/log(2.0); + computedConstants[143] = log10(constants[1]); + computedConstants[144] = log(constants[1])/log(constants[2]); + computedConstants[145] = ceil(constants[1]); + computedConstants[146] = floor(constants[1]); + computedConstants[147] = min(constants[1], constants[2]); + computedConstants[148] = min(constants[1], min(constants[2], constants[6])); + computedConstants[149] = max(constants[1], constants[2]); + computedConstants[150] = max(constants[1], max(constants[2], constants[6])); + computedConstants[151] = fmod(constants[1], constants[2]); + computedConstants[152] = sin(constants[1]); + computedConstants[153] = cos(constants[1]); + computedConstants[154] = tan(constants[1]); + computedConstants[155] = sec(constants[1]); + computedConstants[156] = csc(constants[1]); + computedConstants[157] = cot(constants[1]); + computedConstants[158] = sinh(constants[1]); + computedConstants[159] = cosh(constants[1]); + computedConstants[160] = tanh(constants[1]); + computedConstants[161] = sech(constants[1]); + computedConstants[162] = csch(constants[1]); + computedConstants[163] = coth(constants[1]); + computedConstants[164] = asin(constants[1]); + computedConstants[165] = acos(constants[1]); + computedConstants[166] = atan(constants[1]); + computedConstants[167] = asec(constants[1]); + computedConstants[168] = acsc(constants[1]); + computedConstants[169] = acot(constants[1]); + computedConstants[170] = asinh(constants[1]); + computedConstants[171] = acosh(constants[1]); + computedConstants[172] = atanh(constants[1]/2.0); + computedConstants[173] = asech(constants[1]); + computedConstants[174] = acsch(constants[1]); + computedConstants[175] = acoth(2.0*constants[1]); + computedConstants[176] = (constants[1] > constants[2])?constants[1]:NAN; + computedConstants[177] = (constants[1] > constants[2])?constants[1]:constants[6]; + computedConstants[178] = (constants[1] > constants[2])?constants[1]:(constants[6] > constants[18])?constants[6]:(constants[179] > constants[180])?constants[179]:NAN; + computedConstants[181] = (constants[1] > constants[2])?constants[1]:(constants[6] > constants[18])?constants[6]:(constants[179] > constants[180])?constants[179]:constants[182]; + computedConstants[183] = 123.0+((constants[1] > constants[2])?constants[1]:NAN); + computedConstants[188] = constants[1]; + computedConstants[195] = (constants[1] && constants[2])+((constants[6] > constants[18])?constants[2]:NAN)+constants[179]+(constants[180] && constants[182]); + computedConstants[196] = (constants[1] && constants[2])-(((constants[6] > constants[18])?constants[2]:NAN)-(constants[179]-((constants[6] > constants[18])?constants[2]:NAN)))-(constants[180] && constants[182]); + computedConstants[197] = (constants[1] && constants[2])*((constants[6] > constants[18])?constants[2]:NAN)*constants[179]*((constants[6] > constants[18])?constants[2]:NAN)*(constants[180] && constants[182]); + computedConstants[198] = (constants[1] && constants[2])/(((constants[6] > constants[18])?constants[2]:NAN)/(constants[179]/((constants[6] > constants[18])?constants[2]:NAN))); + computedConstants[199] = (constants[1] || constants[2]) && xor(constants[1], constants[2]) && ((constants[6] > constants[18])?constants[2]:NAN) && constants[179] && ((constants[6] > constants[18])?constants[2]:NAN) && xor(constants[1], constants[2]) && (constants[1] || constants[2]); + computedConstants[200] = (constants[1] && constants[2]) || xor(constants[1], constants[2]) || ((constants[6] > constants[18])?constants[2]:NAN) || constants[179] || ((constants[6] > constants[18])?constants[2]:NAN) || xor(constants[1], constants[2]) || (constants[1] && constants[2]); + computedConstants[201] = xor(constants[1] && constants[2], xor(constants[1] || constants[2], xor((constants[6] > constants[18])?constants[2]:NAN, xor(xor(xor(constants[179], (constants[6] > constants[18])?constants[2]:NAN), constants[1] || constants[2]), constants[1] && constants[2])))); + computedConstants[202] = pow(constants[1] && constants[2], pow((constants[6] > constants[18])?constants[2]:NAN, pow(pow(constants[179], (constants[6] > constants[18])?constants[2]:NAN), constants[1] && constants[2]))); + computedConstants[203] = pow(pow(pow(constants[1] && constants[2], 1.0/pow((constants[6] > constants[18])?constants[2]:NAN, 1.0/constants[179])), 1.0/((constants[6] > constants[18])?constants[2]:NAN)), 1.0/(constants[1] && constants[2])); + computedConstants[204] = -(constants[1] && constants[2])+-((constants[6] > constants[18])?constants[2]:NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index a6c7be6c6..4eeb5c9fa 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -359,239 +359,239 @@ def objective_function_0(u, f, data): rates = data[2] variables = data[3] - variables[205] = u[0] - variables[206] = u[1] + algebraic[205] = u[0] + algebraic[206] = u[1] - f[0] = variables[205]+variables[206]+states[0]-0.0 - f[1] = variables[205]-variables[206]-(variables[207]+variables[208]) + f[0] = algebraic[205]+algebraic[206]+states[0]-0.0 + f[1] = algebraic[205]-algebraic[206]-(computed_constants[207]+computed_constants[208]) def find_root_0(voi, states, rates, variables): u = [nan]*2 - u[0] = variables[205] - u[1] = variables[206] + u[0] = algebraic[205] + u[1] = algebraic[206] u = nla_solve(objective_function_0, u, 2, [voi, states, rates, variables]) - variables[205] = u[0] - variables[206] = u[1] + algebraic[205] = u[0] + algebraic[206] = u[1] def initialise_variables(states, rates, constants): - variables[1] = 1.0 - variables[2] = 2.0 - variables[6] = 3.0 - variables[18] = 4.0 - variables[179] = 5.0 - variables[180] = 6.0 - variables[182] = 7.0 - variables[205] = 1.0 - variables[206] = 2.0 - variables[184] = 123.0 - variables[185] = 123.456789 - variables[186] = 123.0e99 - variables[187] = 123.456789e99 - variables[189] = 1.0 - variables[190] = 0.0 - variables[191] = 2.71828182845905 - variables[192] = 3.14159265358979 - variables[193] = inf - variables[194] = nan - variables[207] = 1.0 - variables[208] = 3.0 + constants[1] = 1.0 + constants[2] = 2.0 + constants[6] = 3.0 + constants[18] = 4.0 + constants[179] = 5.0 + constants[180] = 6.0 + constants[182] = 7.0 + algebraic[205] = 1.0 + algebraic[206] = 2.0 + computed_constants[184] = 123.0 + computed_constants[185] = 123.456789 + computed_constants[186] = 123.0e99 + computed_constants[187] = 123.456789e99 + computed_constants[189] = 1.0 + computed_constants[190] = 0.0 + computed_constants[191] = 2.71828182845905 + computed_constants[192] = 3.14159265358979 + computed_constants[193] = inf + computed_constants[194] = nan + computed_constants[207] = 1.0 + computed_constants[208] = 3.0 states[0] = 0.0 def compute_computed_constants(constants, computed_constants): - variables[0] = eq_func(variables[1], variables[2]) - variables[3] = variables[1]/eq_func(variables[2], variables[2]) - variables[4] = neq_func(variables[1], variables[2]) - variables[5] = variables[1]/neq_func(variables[2], variables[6]) - variables[7] = lt_func(variables[1], variables[2]) - variables[8] = variables[1]/lt_func(variables[2], variables[6]) - variables[9] = leq_func(variables[1], variables[2]) - variables[10] = variables[1]/leq_func(variables[2], variables[6]) - variables[11] = gt_func(variables[1], variables[2]) - variables[12] = variables[1]/gt_func(variables[2], variables[6]) - variables[13] = geq_func(variables[1], variables[2]) - variables[14] = variables[1]/geq_func(variables[2], variables[6]) - variables[15] = and_func(variables[1], variables[2]) - variables[16] = and_func(variables[1], and_func(variables[2], variables[6])) - variables[17] = and_func(lt_func(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[19] = and_func(variables[1]+variables[2], gt_func(variables[6], variables[18])) - variables[20] = and_func(variables[1], gt_func(variables[2], variables[6])) - variables[21] = and_func(variables[1]-variables[2], gt_func(variables[6], variables[18])) - variables[22] = and_func(-variables[1], gt_func(variables[2], variables[6])) - variables[23] = and_func(pow(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[24] = and_func(pow(variables[1], 1.0/variables[2]), gt_func(variables[6], variables[18])) - variables[25] = and_func(lt_func(variables[1], variables[2]), variables[6]+variables[18]) - variables[26] = and_func(lt_func(variables[1], variables[2]), variables[6]) - variables[27] = and_func(lt_func(variables[1], variables[2]), variables[6]-variables[18]) - variables[28] = and_func(lt_func(variables[1], variables[2]), -variables[6]) - variables[29] = and_func(lt_func(variables[1], variables[2]), pow(variables[6], variables[18])) - variables[30] = and_func(lt_func(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])) - variables[31] = variables[1]/and_func(variables[2], variables[6]) - variables[32] = or_func(variables[1], variables[2]) - variables[33] = or_func(variables[1], or_func(variables[2], variables[6])) - variables[34] = or_func(lt_func(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[35] = or_func(variables[1]+variables[2], gt_func(variables[6], variables[18])) - variables[36] = or_func(variables[1], gt_func(variables[2], variables[6])) - variables[37] = or_func(variables[1]-variables[2], gt_func(variables[6], variables[18])) - variables[38] = or_func(-variables[1], gt_func(variables[2], variables[6])) - variables[39] = or_func(pow(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[40] = or_func(pow(variables[1], 1.0/variables[2]), gt_func(variables[6], variables[18])) - variables[41] = or_func(lt_func(variables[1], variables[2]), variables[6]+variables[18]) - variables[42] = or_func(lt_func(variables[1], variables[2]), variables[6]) - variables[43] = or_func(lt_func(variables[1], variables[2]), variables[6]-variables[18]) - variables[44] = or_func(lt_func(variables[1], variables[2]), -variables[6]) - variables[45] = or_func(lt_func(variables[1], variables[2]), pow(variables[6], variables[18])) - variables[46] = or_func(lt_func(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])) - variables[47] = variables[1]/or_func(variables[2], variables[6]) - variables[48] = xor_func(variables[1], variables[2]) - variables[49] = xor_func(variables[1], xor_func(variables[2], variables[6])) - variables[50] = xor_func(lt_func(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[51] = xor_func(variables[1]+variables[2], gt_func(variables[6], variables[18])) - variables[52] = xor_func(variables[1], gt_func(variables[2], variables[6])) - variables[53] = xor_func(variables[1]-variables[2], gt_func(variables[6], variables[18])) - variables[54] = xor_func(-variables[1], gt_func(variables[2], variables[6])) - variables[55] = xor_func(pow(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[56] = xor_func(pow(variables[1], 1.0/variables[2]), gt_func(variables[6], variables[18])) - variables[57] = xor_func(lt_func(variables[1], variables[2]), variables[6]+variables[18]) - variables[58] = xor_func(lt_func(variables[1], variables[2]), variables[6]) - variables[59] = xor_func(lt_func(variables[1], variables[2]), variables[6]-variables[18]) - variables[60] = xor_func(lt_func(variables[1], variables[2]), -variables[6]) - variables[61] = xor_func(lt_func(variables[1], variables[2]), pow(variables[6], variables[18])) - variables[62] = xor_func(lt_func(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])) - variables[63] = variables[1]/xor_func(variables[2], variables[6]) - variables[64] = not_func(variables[1]) - variables[65] = variables[1]+variables[2] - variables[66] = variables[1]+variables[2]+variables[6] - variables[67] = lt_func(variables[1], variables[2])+gt_func(variables[6], variables[18]) - variables[68] = variables[1] - variables[69] = variables[1]-variables[2] - variables[70] = lt_func(variables[1], variables[2])-gt_func(variables[6], variables[18]) - variables[71] = lt_func(variables[1], variables[2])-(variables[6]+variables[18]) - variables[72] = lt_func(variables[1], variables[2])-variables[6] - variables[73] = variables[1]-(-variables[2]) - variables[74] = variables[1]-(-variables[2]*variables[6]) - variables[75] = -variables[1] - variables[76] = -lt_func(variables[1], variables[2]) - variables[77] = variables[1]*variables[2] - variables[78] = variables[1]*variables[2]*variables[6] - variables[79] = lt_func(variables[1], variables[2])*gt_func(variables[6], variables[18]) - variables[80] = (variables[1]+variables[2])*gt_func(variables[6], variables[18]) - variables[81] = variables[1]*gt_func(variables[2], variables[6]) - variables[82] = (variables[1]-variables[2])*gt_func(variables[6], variables[18]) - variables[83] = -variables[1]*gt_func(variables[2], variables[6]) - variables[84] = lt_func(variables[1], variables[2])*(variables[6]+variables[18]) - variables[85] = lt_func(variables[1], variables[2])*variables[6] - variables[86] = lt_func(variables[1], variables[2])*(variables[6]-variables[18]) - variables[87] = lt_func(variables[1], variables[2])*-variables[6] - variables[88] = variables[1]/variables[2] - variables[89] = lt_func(variables[1], variables[2])/gt_func(variables[18], variables[6]) - variables[90] = (variables[1]+variables[2])/gt_func(variables[18], variables[6]) - variables[91] = variables[1]/gt_func(variables[6], variables[2]) - variables[92] = (variables[1]-variables[2])/gt_func(variables[18], variables[6]) - variables[93] = -variables[1]/gt_func(variables[6], variables[2]) - variables[94] = lt_func(variables[1], variables[2])/(variables[6]+variables[18]) - variables[95] = lt_func(variables[1], variables[2])/variables[6] - variables[96] = lt_func(variables[1], variables[2])/(variables[6]-variables[18]) - variables[97] = lt_func(variables[1], variables[2])/-variables[6] - variables[98] = lt_func(variables[1], variables[2])/(variables[6]*variables[18]) - variables[99] = lt_func(variables[1], variables[2])/(variables[6]/variables[18]) - variables[100] = sqrt(variables[1]) - variables[101] = pow(variables[1], 2.0) - variables[102] = pow(variables[1], 3.0) - variables[103] = pow(variables[1], variables[2]) - variables[104] = pow(leq_func(variables[1], variables[2]), geq_func(variables[6], variables[18])) - variables[105] = pow(variables[1]+variables[2], geq_func(variables[6], variables[18])) - variables[106] = pow(variables[1], geq_func(variables[2], variables[6])) - variables[107] = pow(variables[1]-variables[2], geq_func(variables[6], variables[18])) - variables[108] = pow(-variables[1], geq_func(variables[2], variables[6])) - variables[109] = pow(variables[1]*variables[2], geq_func(variables[6], variables[18])) - variables[110] = pow(variables[1]/variables[2], geq_func(variables[6], variables[18])) - variables[111] = pow(leq_func(variables[1], variables[2]), variables[6]+variables[18]) - variables[112] = pow(leq_func(variables[1], variables[2]), variables[6]) - variables[113] = pow(leq_func(variables[1], variables[2]), variables[6]-variables[18]) - variables[114] = pow(leq_func(variables[1], variables[2]), -variables[6]) - variables[115] = pow(leq_func(variables[1], variables[2]), variables[6]*variables[18]) - variables[116] = pow(leq_func(variables[1], variables[2]), variables[6]/variables[18]) - variables[117] = pow(leq_func(variables[1], variables[2]), pow(variables[6], variables[18])) - variables[118] = pow(leq_func(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])) - variables[119] = sqrt(variables[1]) - variables[120] = sqrt(variables[1]) - variables[121] = pow(variables[1], 1.0/3.0) - variables[122] = pow(variables[1], 1.0/variables[2]) - variables[123] = pow(lt_func(variables[1], variables[2]), 1.0/gt_func(variables[18], variables[6])) - variables[124] = pow(variables[1]+variables[2], 1.0/gt_func(variables[18], variables[6])) - variables[125] = pow(variables[1], 1.0/gt_func(variables[6], variables[2])) - variables[126] = pow(variables[1]-variables[2], 1.0/gt_func(variables[18], variables[6])) - variables[127] = pow(-variables[1], 1.0/gt_func(variables[6], variables[2])) - variables[128] = pow(variables[1]*variables[2], 1.0/gt_func(variables[18], variables[6])) - variables[129] = pow(variables[1]/variables[2], 1.0/gt_func(variables[18], variables[6])) - variables[130] = pow(lt_func(variables[1], variables[2]), 1.0/(variables[6]+variables[18])) - variables[131] = pow(lt_func(variables[1], variables[2]), 1.0/variables[6]) - variables[132] = pow(lt_func(variables[1], variables[2]), 1.0/(variables[6]-variables[18])) - variables[133] = pow(lt_func(variables[1], variables[2]), 1.0/-variables[6]) - variables[134] = pow(lt_func(variables[1], variables[2]), 1.0/(variables[6]*variables[18])) - variables[135] = pow(lt_func(variables[1], variables[2]), 1.0/(variables[6]/variables[18])) - variables[136] = pow(lt_func(variables[1], variables[2]), 1.0/pow(variables[6], variables[18])) - variables[137] = pow(lt_func(variables[1], variables[2]), 1.0/pow(variables[6], 1.0/variables[18])) - variables[138] = fabs(variables[1]) - variables[139] = exp(variables[1]) - variables[140] = log(variables[1]) - variables[141] = log10(variables[1]) - variables[142] = log(variables[1])/log(2.0) - variables[143] = log10(variables[1]) - variables[144] = log(variables[1])/log(variables[2]) - variables[145] = ceil(variables[1]) - variables[146] = floor(variables[1]) - variables[147] = min(variables[1], variables[2]) - variables[148] = min(variables[1], min(variables[2], variables[6])) - variables[149] = max(variables[1], variables[2]) - variables[150] = max(variables[1], max(variables[2], variables[6])) - variables[151] = fmod(variables[1], variables[2]) - variables[152] = sin(variables[1]) - variables[153] = cos(variables[1]) - variables[154] = tan(variables[1]) - variables[155] = sec(variables[1]) - variables[156] = csc(variables[1]) - variables[157] = cot(variables[1]) - variables[158] = sinh(variables[1]) - variables[159] = cosh(variables[1]) - variables[160] = tanh(variables[1]) - variables[161] = sech(variables[1]) - variables[162] = csch(variables[1]) - variables[163] = coth(variables[1]) - variables[164] = asin(variables[1]) - variables[165] = acos(variables[1]) - variables[166] = atan(variables[1]) - variables[167] = asec(variables[1]) - variables[168] = acsc(variables[1]) - variables[169] = acot(variables[1]) - variables[170] = asinh(variables[1]) - variables[171] = acosh(variables[1]) - variables[172] = atanh(variables[1]/2.0) - variables[173] = asech(variables[1]) - variables[174] = acsch(variables[1]) - variables[175] = acoth(2.0*variables[1]) - variables[176] = variables[1] if gt_func(variables[1], variables[2]) else nan - variables[177] = variables[1] if gt_func(variables[1], variables[2]) else variables[6] - variables[178] = variables[1] if gt_func(variables[1], variables[2]) else variables[6] if gt_func(variables[6], variables[18]) else variables[179] if gt_func(variables[179], variables[180]) else nan - variables[181] = variables[1] if gt_func(variables[1], variables[2]) else variables[6] if gt_func(variables[6], variables[18]) else variables[179] if gt_func(variables[179], variables[180]) else variables[182] - variables[183] = 123.0+(variables[1] if gt_func(variables[1], variables[2]) else nan) - variables[188] = variables[1] - variables[195] = and_func(variables[1], variables[2])+(variables[2] if gt_func(variables[6], variables[18]) else nan)+variables[179]+and_func(variables[180], variables[182]) - variables[196] = and_func(variables[1], variables[2])-((variables[2] if gt_func(variables[6], variables[18]) else nan)-(variables[179]-(variables[2] if gt_func(variables[6], variables[18]) else nan)))-and_func(variables[180], variables[182]) - variables[197] = and_func(variables[1], variables[2])*(variables[2] if gt_func(variables[6], variables[18]) else nan)*variables[179]*(variables[2] if gt_func(variables[6], variables[18]) else nan)*and_func(variables[180], variables[182]) - variables[198] = and_func(variables[1], variables[2])/((variables[2] if gt_func(variables[6], variables[18]) else nan)/(variables[179]/(variables[2] if gt_func(variables[6], variables[18]) else nan))) - variables[199] = and_func(or_func(variables[1], variables[2]), and_func(xor_func(variables[1], variables[2]), and_func(variables[2] if gt_func(variables[6], variables[18]) else nan, and_func(and_func(and_func(variables[179], variables[2] if gt_func(variables[6], variables[18]) else nan), xor_func(variables[1], variables[2])), or_func(variables[1], variables[2]))))) - variables[200] = or_func(and_func(variables[1], variables[2]), or_func(xor_func(variables[1], variables[2]), or_func(variables[2] if gt_func(variables[6], variables[18]) else nan, or_func(or_func(or_func(variables[179], variables[2] if gt_func(variables[6], variables[18]) else nan), xor_func(variables[1], variables[2])), and_func(variables[1], variables[2]))))) - variables[201] = xor_func(and_func(variables[1], variables[2]), xor_func(or_func(variables[1], variables[2]), xor_func(variables[2] if gt_func(variables[6], variables[18]) else nan, xor_func(xor_func(xor_func(variables[179], variables[2] if gt_func(variables[6], variables[18]) else nan), or_func(variables[1], variables[2])), and_func(variables[1], variables[2]))))) - variables[202] = pow(and_func(variables[1], variables[2]), pow(variables[2] if gt_func(variables[6], variables[18]) else nan, pow(pow(variables[179], variables[2] if gt_func(variables[6], variables[18]) else nan), and_func(variables[1], variables[2])))) - variables[203] = pow(pow(pow(and_func(variables[1], variables[2]), 1.0/pow(variables[2] if gt_func(variables[6], variables[18]) else nan, 1.0/variables[179])), 1.0/(variables[2] if gt_func(variables[6], variables[18]) else nan)), 1.0/and_func(variables[1], variables[2])) - variables[204] = -and_func(variables[1], variables[2])+-(variables[2] if gt_func(variables[6], variables[18]) else nan) + computed_constants[0] = eq_func(constants[1], constants[2]) + computed_constants[3] = constants[1]/eq_func(constants[2], constants[2]) + computed_constants[4] = neq_func(constants[1], constants[2]) + computed_constants[5] = constants[1]/neq_func(constants[2], constants[6]) + computed_constants[7] = lt_func(constants[1], constants[2]) + computed_constants[8] = constants[1]/lt_func(constants[2], constants[6]) + computed_constants[9] = leq_func(constants[1], constants[2]) + computed_constants[10] = constants[1]/leq_func(constants[2], constants[6]) + computed_constants[11] = gt_func(constants[1], constants[2]) + computed_constants[12] = constants[1]/gt_func(constants[2], constants[6]) + computed_constants[13] = geq_func(constants[1], constants[2]) + computed_constants[14] = constants[1]/geq_func(constants[2], constants[6]) + computed_constants[15] = and_func(constants[1], constants[2]) + computed_constants[16] = and_func(constants[1], and_func(constants[2], constants[6])) + computed_constants[17] = and_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[19] = and_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) + computed_constants[20] = and_func(constants[1], gt_func(constants[2], constants[6])) + computed_constants[21] = and_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) + computed_constants[22] = and_func(-constants[1], gt_func(constants[2], constants[6])) + computed_constants[23] = and_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[24] = and_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) + computed_constants[25] = and_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) + computed_constants[26] = and_func(lt_func(constants[1], constants[2]), constants[6]) + computed_constants[27] = and_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) + computed_constants[28] = and_func(lt_func(constants[1], constants[2]), -constants[6]) + computed_constants[29] = and_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) + computed_constants[30] = and_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) + computed_constants[31] = constants[1]/and_func(constants[2], constants[6]) + computed_constants[32] = or_func(constants[1], constants[2]) + computed_constants[33] = or_func(constants[1], or_func(constants[2], constants[6])) + computed_constants[34] = or_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[35] = or_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) + computed_constants[36] = or_func(constants[1], gt_func(constants[2], constants[6])) + computed_constants[37] = or_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) + computed_constants[38] = or_func(-constants[1], gt_func(constants[2], constants[6])) + computed_constants[39] = or_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[40] = or_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) + computed_constants[41] = or_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) + computed_constants[42] = or_func(lt_func(constants[1], constants[2]), constants[6]) + computed_constants[43] = or_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) + computed_constants[44] = or_func(lt_func(constants[1], constants[2]), -constants[6]) + computed_constants[45] = or_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) + computed_constants[46] = or_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) + computed_constants[47] = constants[1]/or_func(constants[2], constants[6]) + computed_constants[48] = xor_func(constants[1], constants[2]) + computed_constants[49] = xor_func(constants[1], xor_func(constants[2], constants[6])) + computed_constants[50] = xor_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[51] = xor_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) + computed_constants[52] = xor_func(constants[1], gt_func(constants[2], constants[6])) + computed_constants[53] = xor_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) + computed_constants[54] = xor_func(-constants[1], gt_func(constants[2], constants[6])) + computed_constants[55] = xor_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[56] = xor_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) + computed_constants[57] = xor_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) + computed_constants[58] = xor_func(lt_func(constants[1], constants[2]), constants[6]) + computed_constants[59] = xor_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) + computed_constants[60] = xor_func(lt_func(constants[1], constants[2]), -constants[6]) + computed_constants[61] = xor_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) + computed_constants[62] = xor_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) + computed_constants[63] = constants[1]/xor_func(constants[2], constants[6]) + computed_constants[64] = not_func(constants[1]) + computed_constants[65] = constants[1]+constants[2] + computed_constants[66] = constants[1]+constants[2]+constants[6] + computed_constants[67] = lt_func(constants[1], constants[2])+gt_func(constants[6], constants[18]) + computed_constants[68] = constants[1] + computed_constants[69] = constants[1]-constants[2] + computed_constants[70] = lt_func(constants[1], constants[2])-gt_func(constants[6], constants[18]) + computed_constants[71] = lt_func(constants[1], constants[2])-(constants[6]+constants[18]) + computed_constants[72] = lt_func(constants[1], constants[2])-constants[6] + computed_constants[73] = constants[1]-(-constants[2]) + computed_constants[74] = constants[1]-(-constants[2]*constants[6]) + computed_constants[75] = -constants[1] + computed_constants[76] = -lt_func(constants[1], constants[2]) + computed_constants[77] = constants[1]*constants[2] + computed_constants[78] = constants[1]*constants[2]*constants[6] + computed_constants[79] = lt_func(constants[1], constants[2])*gt_func(constants[6], constants[18]) + computed_constants[80] = (constants[1]+constants[2])*gt_func(constants[6], constants[18]) + computed_constants[81] = constants[1]*gt_func(constants[2], constants[6]) + computed_constants[82] = (constants[1]-constants[2])*gt_func(constants[6], constants[18]) + computed_constants[83] = -constants[1]*gt_func(constants[2], constants[6]) + computed_constants[84] = lt_func(constants[1], constants[2])*(constants[6]+constants[18]) + computed_constants[85] = lt_func(constants[1], constants[2])*constants[6] + computed_constants[86] = lt_func(constants[1], constants[2])*(constants[6]-constants[18]) + computed_constants[87] = lt_func(constants[1], constants[2])*-constants[6] + computed_constants[88] = constants[1]/constants[2] + computed_constants[89] = lt_func(constants[1], constants[2])/gt_func(constants[18], constants[6]) + computed_constants[90] = (constants[1]+constants[2])/gt_func(constants[18], constants[6]) + computed_constants[91] = constants[1]/gt_func(constants[6], constants[2]) + computed_constants[92] = (constants[1]-constants[2])/gt_func(constants[18], constants[6]) + computed_constants[93] = -constants[1]/gt_func(constants[6], constants[2]) + computed_constants[94] = lt_func(constants[1], constants[2])/(constants[6]+constants[18]) + computed_constants[95] = lt_func(constants[1], constants[2])/constants[6] + computed_constants[96] = lt_func(constants[1], constants[2])/(constants[6]-constants[18]) + computed_constants[97] = lt_func(constants[1], constants[2])/-constants[6] + computed_constants[98] = lt_func(constants[1], constants[2])/(constants[6]*constants[18]) + computed_constants[99] = lt_func(constants[1], constants[2])/(constants[6]/constants[18]) + computed_constants[100] = sqrt(constants[1]) + computed_constants[101] = pow(constants[1], 2.0) + computed_constants[102] = pow(constants[1], 3.0) + computed_constants[103] = pow(constants[1], constants[2]) + computed_constants[104] = pow(leq_func(constants[1], constants[2]), geq_func(constants[6], constants[18])) + computed_constants[105] = pow(constants[1]+constants[2], geq_func(constants[6], constants[18])) + computed_constants[106] = pow(constants[1], geq_func(constants[2], constants[6])) + computed_constants[107] = pow(constants[1]-constants[2], geq_func(constants[6], constants[18])) + computed_constants[108] = pow(-constants[1], geq_func(constants[2], constants[6])) + computed_constants[109] = pow(constants[1]*constants[2], geq_func(constants[6], constants[18])) + computed_constants[110] = pow(constants[1]/constants[2], geq_func(constants[6], constants[18])) + computed_constants[111] = pow(leq_func(constants[1], constants[2]), constants[6]+constants[18]) + computed_constants[112] = pow(leq_func(constants[1], constants[2]), constants[6]) + computed_constants[113] = pow(leq_func(constants[1], constants[2]), constants[6]-constants[18]) + computed_constants[114] = pow(leq_func(constants[1], constants[2]), -constants[6]) + computed_constants[115] = pow(leq_func(constants[1], constants[2]), constants[6]*constants[18]) + computed_constants[116] = pow(leq_func(constants[1], constants[2]), constants[6]/constants[18]) + computed_constants[117] = pow(leq_func(constants[1], constants[2]), pow(constants[6], constants[18])) + computed_constants[118] = pow(leq_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) + computed_constants[119] = sqrt(constants[1]) + computed_constants[120] = sqrt(constants[1]) + computed_constants[121] = pow(constants[1], 1.0/3.0) + computed_constants[122] = pow(constants[1], 1.0/constants[2]) + computed_constants[123] = pow(lt_func(constants[1], constants[2]), 1.0/gt_func(constants[18], constants[6])) + computed_constants[124] = pow(constants[1]+constants[2], 1.0/gt_func(constants[18], constants[6])) + computed_constants[125] = pow(constants[1], 1.0/gt_func(constants[6], constants[2])) + computed_constants[126] = pow(constants[1]-constants[2], 1.0/gt_func(constants[18], constants[6])) + computed_constants[127] = pow(-constants[1], 1.0/gt_func(constants[6], constants[2])) + computed_constants[128] = pow(constants[1]*constants[2], 1.0/gt_func(constants[18], constants[6])) + computed_constants[129] = pow(constants[1]/constants[2], 1.0/gt_func(constants[18], constants[6])) + computed_constants[130] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]+constants[18])) + computed_constants[131] = pow(lt_func(constants[1], constants[2]), 1.0/constants[6]) + computed_constants[132] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]-constants[18])) + computed_constants[133] = pow(lt_func(constants[1], constants[2]), 1.0/-constants[6]) + computed_constants[134] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]*constants[18])) + computed_constants[135] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]/constants[18])) + computed_constants[136] = pow(lt_func(constants[1], constants[2]), 1.0/pow(constants[6], constants[18])) + computed_constants[137] = pow(lt_func(constants[1], constants[2]), 1.0/pow(constants[6], 1.0/constants[18])) + computed_constants[138] = fabs(constants[1]) + computed_constants[139] = exp(constants[1]) + computed_constants[140] = log(constants[1]) + computed_constants[141] = log10(constants[1]) + computed_constants[142] = log(constants[1])/log(2.0) + computed_constants[143] = log10(constants[1]) + computed_constants[144] = log(constants[1])/log(constants[2]) + computed_constants[145] = ceil(constants[1]) + computed_constants[146] = floor(constants[1]) + computed_constants[147] = min(constants[1], constants[2]) + computed_constants[148] = min(constants[1], min(constants[2], constants[6])) + computed_constants[149] = max(constants[1], constants[2]) + computed_constants[150] = max(constants[1], max(constants[2], constants[6])) + computed_constants[151] = fmod(constants[1], constants[2]) + computed_constants[152] = sin(constants[1]) + computed_constants[153] = cos(constants[1]) + computed_constants[154] = tan(constants[1]) + computed_constants[155] = sec(constants[1]) + computed_constants[156] = csc(constants[1]) + computed_constants[157] = cot(constants[1]) + computed_constants[158] = sinh(constants[1]) + computed_constants[159] = cosh(constants[1]) + computed_constants[160] = tanh(constants[1]) + computed_constants[161] = sech(constants[1]) + computed_constants[162] = csch(constants[1]) + computed_constants[163] = coth(constants[1]) + computed_constants[164] = asin(constants[1]) + computed_constants[165] = acos(constants[1]) + computed_constants[166] = atan(constants[1]) + computed_constants[167] = asec(constants[1]) + computed_constants[168] = acsc(constants[1]) + computed_constants[169] = acot(constants[1]) + computed_constants[170] = asinh(constants[1]) + computed_constants[171] = acosh(constants[1]) + computed_constants[172] = atanh(constants[1]/2.0) + computed_constants[173] = asech(constants[1]) + computed_constants[174] = acsch(constants[1]) + computed_constants[175] = acoth(2.0*constants[1]) + computed_constants[176] = constants[1] if gt_func(constants[1], constants[2]) else nan + computed_constants[177] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] + computed_constants[178] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] if gt_func(constants[6], constants[18]) else constants[179] if gt_func(constants[179], constants[180]) else nan + computed_constants[181] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] if gt_func(constants[6], constants[18]) else constants[179] if gt_func(constants[179], constants[180]) else constants[182] + computed_constants[183] = 123.0+(constants[1] if gt_func(constants[1], constants[2]) else nan) + computed_constants[188] = constants[1] + computed_constants[195] = and_func(constants[1], constants[2])+(constants[2] if gt_func(constants[6], constants[18]) else nan)+constants[179]+and_func(constants[180], constants[182]) + computed_constants[196] = and_func(constants[1], constants[2])-((constants[2] if gt_func(constants[6], constants[18]) else nan)-(constants[179]-(constants[2] if gt_func(constants[6], constants[18]) else nan)))-and_func(constants[180], constants[182]) + computed_constants[197] = and_func(constants[1], constants[2])*(constants[2] if gt_func(constants[6], constants[18]) else nan)*constants[179]*(constants[2] if gt_func(constants[6], constants[18]) else nan)*and_func(constants[180], constants[182]) + computed_constants[198] = and_func(constants[1], constants[2])/((constants[2] if gt_func(constants[6], constants[18]) else nan)/(constants[179]/(constants[2] if gt_func(constants[6], constants[18]) else nan))) + computed_constants[199] = and_func(or_func(constants[1], constants[2]), and_func(xor_func(constants[1], constants[2]), and_func(constants[2] if gt_func(constants[6], constants[18]) else nan, and_func(and_func(and_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), xor_func(constants[1], constants[2])), or_func(constants[1], constants[2]))))) + computed_constants[200] = or_func(and_func(constants[1], constants[2]), or_func(xor_func(constants[1], constants[2]), or_func(constants[2] if gt_func(constants[6], constants[18]) else nan, or_func(or_func(or_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), xor_func(constants[1], constants[2])), and_func(constants[1], constants[2]))))) + computed_constants[201] = xor_func(and_func(constants[1], constants[2]), xor_func(or_func(constants[1], constants[2]), xor_func(constants[2] if gt_func(constants[6], constants[18]) else nan, xor_func(xor_func(xor_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), or_func(constants[1], constants[2])), and_func(constants[1], constants[2]))))) + computed_constants[202] = pow(and_func(constants[1], constants[2]), pow(constants[2] if gt_func(constants[6], constants[18]) else nan, pow(pow(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), and_func(constants[1], constants[2])))) + computed_constants[203] = pow(pow(pow(and_func(constants[1], constants[2]), 1.0/pow(constants[2] if gt_func(constants[6], constants[18]) else nan, 1.0/constants[179])), 1.0/(constants[2] if gt_func(constants[6], constants[18]) else nan)), 1.0/and_func(constants[1], constants[2])) + computed_constants[204] = -and_func(constants[1], constants[2])+-(constants[2] if gt_func(constants[6], constants[18]) else nan) def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index b4c4b8088..f35ae1622 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -95,11 +95,11 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[205] = u[0]; - variables[206] = u[1]; + algebraic[205] = u[0]; + algebraic[206] = u[1]; - f[0] = variables[205]+variables[206]+states[0]-0.0; - f[1] = variables[205]-variables[206]-(variables[207]+variables[208]); + f[0] = algebraic[205]+algebraic[206]+states[0]-0.0; + f[1] = algebraic[205]-algebraic[206]-(computedConstants[207]+computedConstants[208]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -107,231 +107,231 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[2]; - u[0] = variables[205]; - u[1] = variables[206]; + u[0] = algebraic[205]; + u[1] = algebraic[206]; nlaSolve(objectiveFunction0, u, 2, &rfi); - variables[205] = u[0]; - variables[206] = u[1]; + algebraic[205] = u[0]; + algebraic[206] = u[1]; } void initialiseVariables(double *states, double *rates, double *constants) { - variables[1] = 1.0; - variables[2] = 2.0; - variables[6] = 3.0; - variables[18] = 4.0; - variables[179] = 5.0; - variables[180] = 6.0; - variables[182] = 7.0; - variables[205] = 1.0; - variables[206] = 2.0; - variables[184] = 123.0; - variables[185] = 123.456789; - variables[186] = 123.0e99; - variables[187] = 123.456789e99; - variables[189] = 1.0; - variables[190] = 0.0; - variables[191] = 2.71828182845905; - variables[192] = 3.14159265358979; - variables[193] = INFINITY; - variables[194] = NAN; - variables[207] = 1.0; - variables[208] = 3.0; + constants[1] = 1.0; + constants[2] = 2.0; + constants[6] = 3.0; + constants[18] = 4.0; + constants[179] = 5.0; + constants[180] = 6.0; + constants[182] = 7.0; + algebraic[205] = 1.0; + algebraic[206] = 2.0; + computedConstants[184] = 123.0; + computedConstants[185] = 123.456789; + computedConstants[186] = 123.0e99; + computedConstants[187] = 123.456789e99; + computedConstants[189] = 1.0; + computedConstants[190] = 0.0; + computedConstants[191] = 2.71828182845905; + computedConstants[192] = 3.14159265358979; + computedConstants[193] = INFINITY; + computedConstants[194] = NAN; + computedConstants[207] = 1.0; + computedConstants[208] = 3.0; states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { - variables[0] = variables[1] == variables[2]; - variables[3] = variables[1]/(variables[2] == variables[2]); - variables[4] = variables[1] != variables[2]; - variables[5] = variables[1]/(variables[2] != variables[6]); - variables[7] = variables[1] < variables[2]; - variables[8] = variables[1]/(variables[2] < variables[6]); - variables[9] = variables[1] <= variables[2]; - variables[10] = variables[1]/(variables[2] <= variables[6]); - variables[11] = variables[1] > variables[2]; - variables[12] = variables[1]/(variables[2] > variables[6]); - variables[13] = variables[1] >= variables[2]; - variables[14] = variables[1]/(variables[2] >= variables[6]); - variables[15] = variables[1] && variables[2]; - variables[16] = variables[1] && variables[2] && variables[6]; - variables[17] = (variables[1] < variables[2]) && (variables[6] > variables[18]); - variables[19] = (variables[1]+variables[2]) && (variables[6] > variables[18]); - variables[20] = variables[1] && (variables[2] > variables[6]); - variables[21] = (variables[1]-variables[2]) && (variables[6] > variables[18]); - variables[22] = -variables[1] && (variables[2] > variables[6]); - variables[23] = (variables[1]^^variables[2]) && (variables[6] > variables[18]); - variables[24] = (variables[1]^^(1.0/variables[2])) && (variables[6] > variables[18]); - variables[25] = (variables[1] < variables[2]) && (variables[6]+variables[18]); - variables[26] = (variables[1] < variables[2]) && variables[6]; - variables[27] = (variables[1] < variables[2]) && (variables[6]-variables[18]); - variables[28] = (variables[1] < variables[2]) && -variables[6]; - variables[29] = (variables[1] < variables[2]) && (variables[6]^^variables[18]); - variables[30] = (variables[1] < variables[2]) && (variables[6]^^(1.0/variables[18])); - variables[31] = variables[1]/(variables[2] && variables[6]); - variables[32] = variables[1] || variables[2]; - variables[33] = variables[1] || variables[2] || variables[6]; - variables[34] = (variables[1] < variables[2]) || (variables[6] > variables[18]); - variables[35] = (variables[1]+variables[2]) || (variables[6] > variables[18]); - variables[36] = variables[1] || (variables[2] > variables[6]); - variables[37] = (variables[1]-variables[2]) || (variables[6] > variables[18]); - variables[38] = -variables[1] || (variables[2] > variables[6]); - variables[39] = (variables[1]^^variables[2]) || (variables[6] > variables[18]); - variables[40] = (variables[1]^^(1.0/variables[2])) || (variables[6] > variables[18]); - variables[41] = (variables[1] < variables[2]) || (variables[6]+variables[18]); - variables[42] = (variables[1] < variables[2]) || variables[6]; - variables[43] = (variables[1] < variables[2]) || (variables[6]-variables[18]); - variables[44] = (variables[1] < variables[2]) || -variables[6]; - variables[45] = (variables[1] < variables[2]) || (variables[6]^^variables[18]); - variables[46] = (variables[1] < variables[2]) || (variables[6]^^(1.0/variables[18])); - variables[47] = variables[1]/(variables[2] || variables[6]); - variables[48] = variables[1]^variables[2]; - variables[49] = variables[1]^variables[2]^variables[6]; - variables[50] = (variables[1] < variables[2])^(variables[6] > variables[18]); - variables[51] = (variables[1]+variables[2])^(variables[6] > variables[18]); - variables[52] = variables[1]^(variables[2] > variables[6]); - variables[53] = (variables[1]-variables[2])^(variables[6] > variables[18]); - variables[54] = -variables[1]^(variables[2] > variables[6]); - variables[55] = (variables[1]^^variables[2])^(variables[6] > variables[18]); - variables[56] = (variables[1]^^(1.0/variables[2]))^(variables[6] > variables[18]); - variables[57] = (variables[1] < variables[2])^(variables[6]+variables[18]); - variables[58] = (variables[1] < variables[2])^variables[6]; - variables[59] = (variables[1] < variables[2])^(variables[6]-variables[18]); - variables[60] = (variables[1] < variables[2])^-variables[6]; - variables[61] = (variables[1] < variables[2])^(variables[6]^^variables[18]); - variables[62] = (variables[1] < variables[2])^(variables[6]^^(1.0/variables[18])); - variables[63] = variables[1]/(variables[2]^variables[6]); - variables[64] = !variables[1]; - variables[65] = variables[1]+variables[2]; - variables[66] = variables[1]+variables[2]+variables[6]; - variables[67] = (variables[1] < variables[2])+(variables[6] > variables[18]); - variables[68] = variables[1]; - variables[69] = variables[1]-variables[2]; - variables[70] = (variables[1] < variables[2])-(variables[6] > variables[18]); - variables[71] = (variables[1] < variables[2])-(variables[6]+variables[18]); - variables[72] = (variables[1] < variables[2])-variables[6]; - variables[73] = variables[1]-(-variables[2]); - variables[74] = variables[1]-(-variables[2]*variables[6]); - variables[75] = -variables[1]; - variables[76] = -(variables[1] < variables[2]); - variables[77] = variables[1]*variables[2]; - variables[78] = variables[1]*variables[2]*variables[6]; - variables[79] = (variables[1] < variables[2])*(variables[6] > variables[18]); - variables[80] = (variables[1]+variables[2])*(variables[6] > variables[18]); - variables[81] = variables[1]*(variables[2] > variables[6]); - variables[82] = (variables[1]-variables[2])*(variables[6] > variables[18]); - variables[83] = -variables[1]*(variables[2] > variables[6]); - variables[84] = (variables[1] < variables[2])*(variables[6]+variables[18]); - variables[85] = (variables[1] < variables[2])*variables[6]; - variables[86] = (variables[1] < variables[2])*(variables[6]-variables[18]); - variables[87] = (variables[1] < variables[2])*-variables[6]; - variables[88] = variables[1]/variables[2]; - variables[89] = (variables[1] < variables[2])/(variables[18] > variables[6]); - variables[90] = (variables[1]+variables[2])/(variables[18] > variables[6]); - variables[91] = variables[1]/(variables[6] > variables[2]); - variables[92] = (variables[1]-variables[2])/(variables[18] > variables[6]); - variables[93] = -variables[1]/(variables[6] > variables[2]); - variables[94] = (variables[1] < variables[2])/(variables[6]+variables[18]); - variables[95] = (variables[1] < variables[2])/variables[6]; - variables[96] = (variables[1] < variables[2])/(variables[6]-variables[18]); - variables[97] = (variables[1] < variables[2])/-variables[6]; - variables[98] = (variables[1] < variables[2])/(variables[6]*variables[18]); - variables[99] = (variables[1] < variables[2])/(variables[6]/variables[18]); - variables[100] = sqrt(variables[1]); - variables[101] = sqr(variables[1]); - variables[102] = variables[1]^^3.0; - variables[103] = variables[1]^^variables[2]; - variables[104] = (variables[1] <= variables[2])^^(variables[6] >= variables[18]); - variables[105] = (variables[1]+variables[2])^^(variables[6] >= variables[18]); - variables[106] = variables[1]^^(variables[2] >= variables[6]); - variables[107] = (variables[1]-variables[2])^^(variables[6] >= variables[18]); - variables[108] = (-variables[1])^^(variables[2] >= variables[6]); - variables[109] = (variables[1]*variables[2])^^(variables[6] >= variables[18]); - variables[110] = (variables[1]/variables[2])^^(variables[6] >= variables[18]); - variables[111] = (variables[1] <= variables[2])^^(variables[6]+variables[18]); - variables[112] = (variables[1] <= variables[2])^^variables[6]; - variables[113] = (variables[1] <= variables[2])^^variables[6]-variables[18]; - variables[114] = (variables[1] <= variables[2])^^-variables[6]; - variables[115] = (variables[1] <= variables[2])^^(variables[6]*variables[18]); - variables[116] = (variables[1] <= variables[2])^^(variables[6]/variables[18]); - variables[117] = (variables[1] <= variables[2])^^(variables[6]^^variables[18]); - variables[118] = (variables[1] <= variables[2])^^(variables[6]^^(1.0/variables[18])); - variables[119] = sqrt(variables[1]); - variables[120] = sqrt(variables[1]); - variables[121] = variables[1]^^(1.0/3.0); - variables[122] = variables[1]^^(1.0/variables[2]); - variables[123] = (variables[1] < variables[2])^^(1.0/(variables[18] > variables[6])); - variables[124] = (variables[1]+variables[2])^^(1.0/(variables[18] > variables[6])); - variables[125] = variables[1]^^(1.0/(variables[6] > variables[2])); - variables[126] = (variables[1]-variables[2])^^(1.0/(variables[18] > variables[6])); - variables[127] = (-variables[1])^^(1.0/(variables[6] > variables[2])); - variables[128] = (variables[1]*variables[2])^^(1.0/(variables[18] > variables[6])); - variables[129] = (variables[1]/variables[2])^^(1.0/(variables[18] > variables[6])); - variables[130] = (variables[1] < variables[2])^^(1.0/(variables[6]+variables[18])); - variables[131] = (variables[1] < variables[2])^^(1.0/variables[6]); - variables[132] = (variables[1] < variables[2])^^(1.0/(variables[6]-variables[18])); - variables[133] = (variables[1] < variables[2])^^(1.0/(-variables[6])); - variables[134] = (variables[1] < variables[2])^^(1.0/(variables[6]*variables[18])); - variables[135] = (variables[1] < variables[2])^^(1.0/(variables[6]/variables[18])); - variables[136] = (variables[1] < variables[2])^^(1.0/(variables[6]^^variables[18])); - variables[137] = (variables[1] < variables[2])^^(1.0/(variables[6]^^(1.0/variables[18]))); - variables[138] = fabs(variables[1]); - variables[139] = exp(variables[1]); - variables[140] = log(variables[1]); - variables[141] = log10(variables[1]); - variables[142] = log(variables[1])/log(2.0); - variables[143] = log10(variables[1]); - variables[144] = log(variables[1])/log(variables[2]); - variables[145] = ceil(variables[1]); - variables[146] = floor(variables[1]); - variables[147] = min(variables[1], variables[2]); - variables[148] = min(variables[1], min(variables[2], variables[6])); - variables[149] = max(variables[1], variables[2]); - variables[150] = max(variables[1], max(variables[2], variables[6])); - variables[151] = fmod(variables[1], variables[2]); - variables[152] = sin(variables[1]); - variables[153] = cos(variables[1]); - variables[154] = tan(variables[1]); - variables[155] = sec(variables[1]); - variables[156] = csc(variables[1]); - variables[157] = cot(variables[1]); - variables[158] = sinh(variables[1]); - variables[159] = cosh(variables[1]); - variables[160] = tanh(variables[1]); - variables[161] = sech(variables[1]); - variables[162] = csch(variables[1]); - variables[163] = coth(variables[1]); - variables[164] = asin(variables[1]); - variables[165] = acos(variables[1]); - variables[166] = atan(variables[1]); - variables[167] = asec(variables[1]); - variables[168] = acsc(variables[1]); - variables[169] = acot(variables[1]); - variables[170] = asinh(variables[1]); - variables[171] = acosh(variables[1]); - variables[172] = atanh(variables[1]/2.0); - variables[173] = asech(variables[1]); - variables[174] = acsch(variables[1]); - variables[175] = acoth(2.0*variables[1]); - variables[176] = piecewise(variables[1] > variables[2], variables[1], NAN); - variables[177] = piecewise(variables[1] > variables[2], variables[1], variables[6]); - variables[178] = piecewise(variables[1] > variables[2], variables[1], piecewise(variables[6] > variables[18], variables[6], piecewise(variables[179] > variables[180], variables[179], NAN))); - variables[181] = piecewise(variables[1] > variables[2], variables[1], piecewise(variables[6] > variables[18], variables[6], piecewise(variables[179] > variables[180], variables[179], variables[182]))); - variables[183] = 123.0+piecewise(variables[1] > variables[2], variables[1], NAN); - variables[188] = variables[1]; - variables[195] = (variables[1] && variables[2])+piecewise(variables[6] > variables[18], variables[2], NAN)+variables[179]+(variables[180] && variables[182]); - variables[196] = (variables[1] && variables[2])-(piecewise(variables[6] > variables[18], variables[2], NAN)-(variables[179]-piecewise(variables[6] > variables[18], variables[2], NAN)))-(variables[180] && variables[182]); - variables[197] = (variables[1] && variables[2])*piecewise(variables[6] > variables[18], variables[2], NAN)*variables[179]*piecewise(variables[6] > variables[18], variables[2], NAN)*(variables[180] && variables[182]); - variables[198] = (variables[1] && variables[2])/(piecewise(variables[6] > variables[18], variables[2], NAN)/(variables[179]/piecewise(variables[6] > variables[18], variables[2], NAN))); - variables[199] = (variables[1] || variables[2]) && (variables[1]^variables[2]) && piecewise(variables[6] > variables[18], variables[2], NAN) && variables[179] && piecewise(variables[6] > variables[18], variables[2], NAN) && (variables[1]^variables[2]) && (variables[1] || variables[2]); - variables[200] = (variables[1] && variables[2]) || (variables[1]^variables[2]) || piecewise(variables[6] > variables[18], variables[2], NAN) || variables[179] || piecewise(variables[6] > variables[18], variables[2], NAN) || (variables[1]^variables[2]) || (variables[1] && variables[2]); - variables[201] = (variables[1] && variables[2])^(variables[1] || variables[2])^piecewise(variables[6] > variables[18], variables[2], NAN)^variables[179]^piecewise(variables[6] > variables[18], variables[2], NAN)^(variables[1] || variables[2])^(variables[1] && variables[2]); - variables[202] = (variables[1] && variables[2])^^(piecewise(variables[6] > variables[18], variables[2], NAN)^^(variables[179]^^piecewise(variables[6] > variables[18], variables[2], NAN)^^(variables[1] && variables[2]))); - variables[203] = (variables[1] && variables[2])^^(1.0/(piecewise(variables[6] > variables[18], variables[2], NAN)^^(1.0/variables[179])))^^(1.0/piecewise(variables[6] > variables[18], variables[2], NAN))^^(1.0/(variables[1] && variables[2])); - variables[204] = -(variables[1] && variables[2])+-piecewise(variables[6] > variables[18], variables[2], NAN); + computedConstants[0] = constants[1] == constants[2]; + computedConstants[3] = constants[1]/(constants[2] == constants[2]); + computedConstants[4] = constants[1] != constants[2]; + computedConstants[5] = constants[1]/(constants[2] != constants[6]); + computedConstants[7] = constants[1] < constants[2]; + computedConstants[8] = constants[1]/(constants[2] < constants[6]); + computedConstants[9] = constants[1] <= constants[2]; + computedConstants[10] = constants[1]/(constants[2] <= constants[6]); + computedConstants[11] = constants[1] > constants[2]; + computedConstants[12] = constants[1]/(constants[2] > constants[6]); + computedConstants[13] = constants[1] >= constants[2]; + computedConstants[14] = constants[1]/(constants[2] >= constants[6]); + computedConstants[15] = constants[1] && constants[2]; + computedConstants[16] = constants[1] && constants[2] && constants[6]; + computedConstants[17] = (constants[1] < constants[2]) && (constants[6] > constants[18]); + computedConstants[19] = (constants[1]+constants[2]) && (constants[6] > constants[18]); + computedConstants[20] = constants[1] && (constants[2] > constants[6]); + computedConstants[21] = (constants[1]-constants[2]) && (constants[6] > constants[18]); + computedConstants[22] = -constants[1] && (constants[2] > constants[6]); + computedConstants[23] = (constants[1]^^constants[2]) && (constants[6] > constants[18]); + computedConstants[24] = (constants[1]^^(1.0/constants[2])) && (constants[6] > constants[18]); + computedConstants[25] = (constants[1] < constants[2]) && (constants[6]+constants[18]); + computedConstants[26] = (constants[1] < constants[2]) && constants[6]; + computedConstants[27] = (constants[1] < constants[2]) && (constants[6]-constants[18]); + computedConstants[28] = (constants[1] < constants[2]) && -constants[6]; + computedConstants[29] = (constants[1] < constants[2]) && (constants[6]^^constants[18]); + computedConstants[30] = (constants[1] < constants[2]) && (constants[6]^^(1.0/constants[18])); + computedConstants[31] = constants[1]/(constants[2] && constants[6]); + computedConstants[32] = constants[1] || constants[2]; + computedConstants[33] = constants[1] || constants[2] || constants[6]; + computedConstants[34] = (constants[1] < constants[2]) || (constants[6] > constants[18]); + computedConstants[35] = (constants[1]+constants[2]) || (constants[6] > constants[18]); + computedConstants[36] = constants[1] || (constants[2] > constants[6]); + computedConstants[37] = (constants[1]-constants[2]) || (constants[6] > constants[18]); + computedConstants[38] = -constants[1] || (constants[2] > constants[6]); + computedConstants[39] = (constants[1]^^constants[2]) || (constants[6] > constants[18]); + computedConstants[40] = (constants[1]^^(1.0/constants[2])) || (constants[6] > constants[18]); + computedConstants[41] = (constants[1] < constants[2]) || (constants[6]+constants[18]); + computedConstants[42] = (constants[1] < constants[2]) || constants[6]; + computedConstants[43] = (constants[1] < constants[2]) || (constants[6]-constants[18]); + computedConstants[44] = (constants[1] < constants[2]) || -constants[6]; + computedConstants[45] = (constants[1] < constants[2]) || (constants[6]^^constants[18]); + computedConstants[46] = (constants[1] < constants[2]) || (constants[6]^^(1.0/constants[18])); + computedConstants[47] = constants[1]/(constants[2] || constants[6]); + computedConstants[48] = constants[1]^constants[2]; + computedConstants[49] = constants[1]^constants[2]^constants[6]; + computedConstants[50] = (constants[1] < constants[2])^(constants[6] > constants[18]); + computedConstants[51] = (constants[1]+constants[2])^(constants[6] > constants[18]); + computedConstants[52] = constants[1]^(constants[2] > constants[6]); + computedConstants[53] = (constants[1]-constants[2])^(constants[6] > constants[18]); + computedConstants[54] = -constants[1]^(constants[2] > constants[6]); + computedConstants[55] = (constants[1]^^constants[2])^(constants[6] > constants[18]); + computedConstants[56] = (constants[1]^^(1.0/constants[2]))^(constants[6] > constants[18]); + computedConstants[57] = (constants[1] < constants[2])^(constants[6]+constants[18]); + computedConstants[58] = (constants[1] < constants[2])^constants[6]; + computedConstants[59] = (constants[1] < constants[2])^(constants[6]-constants[18]); + computedConstants[60] = (constants[1] < constants[2])^-constants[6]; + computedConstants[61] = (constants[1] < constants[2])^(constants[6]^^constants[18]); + computedConstants[62] = (constants[1] < constants[2])^(constants[6]^^(1.0/constants[18])); + computedConstants[63] = constants[1]/(constants[2]^constants[6]); + computedConstants[64] = !constants[1]; + computedConstants[65] = constants[1]+constants[2]; + computedConstants[66] = constants[1]+constants[2]+constants[6]; + computedConstants[67] = (constants[1] < constants[2])+(constants[6] > constants[18]); + computedConstants[68] = constants[1]; + computedConstants[69] = constants[1]-constants[2]; + computedConstants[70] = (constants[1] < constants[2])-(constants[6] > constants[18]); + computedConstants[71] = (constants[1] < constants[2])-(constants[6]+constants[18]); + computedConstants[72] = (constants[1] < constants[2])-constants[6]; + computedConstants[73] = constants[1]-(-constants[2]); + computedConstants[74] = constants[1]-(-constants[2]*constants[6]); + computedConstants[75] = -constants[1]; + computedConstants[76] = -(constants[1] < constants[2]); + computedConstants[77] = constants[1]*constants[2]; + computedConstants[78] = constants[1]*constants[2]*constants[6]; + computedConstants[79] = (constants[1] < constants[2])*(constants[6] > constants[18]); + computedConstants[80] = (constants[1]+constants[2])*(constants[6] > constants[18]); + computedConstants[81] = constants[1]*(constants[2] > constants[6]); + computedConstants[82] = (constants[1]-constants[2])*(constants[6] > constants[18]); + computedConstants[83] = -constants[1]*(constants[2] > constants[6]); + computedConstants[84] = (constants[1] < constants[2])*(constants[6]+constants[18]); + computedConstants[85] = (constants[1] < constants[2])*constants[6]; + computedConstants[86] = (constants[1] < constants[2])*(constants[6]-constants[18]); + computedConstants[87] = (constants[1] < constants[2])*-constants[6]; + computedConstants[88] = constants[1]/constants[2]; + computedConstants[89] = (constants[1] < constants[2])/(constants[18] > constants[6]); + computedConstants[90] = (constants[1]+constants[2])/(constants[18] > constants[6]); + computedConstants[91] = constants[1]/(constants[6] > constants[2]); + computedConstants[92] = (constants[1]-constants[2])/(constants[18] > constants[6]); + computedConstants[93] = -constants[1]/(constants[6] > constants[2]); + computedConstants[94] = (constants[1] < constants[2])/(constants[6]+constants[18]); + computedConstants[95] = (constants[1] < constants[2])/constants[6]; + computedConstants[96] = (constants[1] < constants[2])/(constants[6]-constants[18]); + computedConstants[97] = (constants[1] < constants[2])/-constants[6]; + computedConstants[98] = (constants[1] < constants[2])/(constants[6]*constants[18]); + computedConstants[99] = (constants[1] < constants[2])/(constants[6]/constants[18]); + computedConstants[100] = sqrt(constants[1]); + computedConstants[101] = sqr(constants[1]); + computedConstants[102] = constants[1]^^3.0; + computedConstants[103] = constants[1]^^constants[2]; + computedConstants[104] = (constants[1] <= constants[2])^^(constants[6] >= constants[18]); + computedConstants[105] = (constants[1]+constants[2])^^(constants[6] >= constants[18]); + computedConstants[106] = constants[1]^^(constants[2] >= constants[6]); + computedConstants[107] = (constants[1]-constants[2])^^(constants[6] >= constants[18]); + computedConstants[108] = (-constants[1])^^(constants[2] >= constants[6]); + computedConstants[109] = (constants[1]*constants[2])^^(constants[6] >= constants[18]); + computedConstants[110] = (constants[1]/constants[2])^^(constants[6] >= constants[18]); + computedConstants[111] = (constants[1] <= constants[2])^^(constants[6]+constants[18]); + computedConstants[112] = (constants[1] <= constants[2])^^constants[6]; + computedConstants[113] = (constants[1] <= constants[2])^^constants[6]-constants[18]; + computedConstants[114] = (constants[1] <= constants[2])^^-constants[6]; + computedConstants[115] = (constants[1] <= constants[2])^^(constants[6]*constants[18]); + computedConstants[116] = (constants[1] <= constants[2])^^(constants[6]/constants[18]); + computedConstants[117] = (constants[1] <= constants[2])^^(constants[6]^^constants[18]); + computedConstants[118] = (constants[1] <= constants[2])^^(constants[6]^^(1.0/constants[18])); + computedConstants[119] = sqrt(constants[1]); + computedConstants[120] = sqrt(constants[1]); + computedConstants[121] = constants[1]^^(1.0/3.0); + computedConstants[122] = constants[1]^^(1.0/constants[2]); + computedConstants[123] = (constants[1] < constants[2])^^(1.0/(constants[18] > constants[6])); + computedConstants[124] = (constants[1]+constants[2])^^(1.0/(constants[18] > constants[6])); + computedConstants[125] = constants[1]^^(1.0/(constants[6] > constants[2])); + computedConstants[126] = (constants[1]-constants[2])^^(1.0/(constants[18] > constants[6])); + computedConstants[127] = (-constants[1])^^(1.0/(constants[6] > constants[2])); + computedConstants[128] = (constants[1]*constants[2])^^(1.0/(constants[18] > constants[6])); + computedConstants[129] = (constants[1]/constants[2])^^(1.0/(constants[18] > constants[6])); + computedConstants[130] = (constants[1] < constants[2])^^(1.0/(constants[6]+constants[18])); + computedConstants[131] = (constants[1] < constants[2])^^(1.0/constants[6]); + computedConstants[132] = (constants[1] < constants[2])^^(1.0/(constants[6]-constants[18])); + computedConstants[133] = (constants[1] < constants[2])^^(1.0/(-constants[6])); + computedConstants[134] = (constants[1] < constants[2])^^(1.0/(constants[6]*constants[18])); + computedConstants[135] = (constants[1] < constants[2])^^(1.0/(constants[6]/constants[18])); + computedConstants[136] = (constants[1] < constants[2])^^(1.0/(constants[6]^^constants[18])); + computedConstants[137] = (constants[1] < constants[2])^^(1.0/(constants[6]^^(1.0/constants[18]))); + computedConstants[138] = fabs(constants[1]); + computedConstants[139] = exp(constants[1]); + computedConstants[140] = log(constants[1]); + computedConstants[141] = log10(constants[1]); + computedConstants[142] = log(constants[1])/log(2.0); + computedConstants[143] = log10(constants[1]); + computedConstants[144] = log(constants[1])/log(constants[2]); + computedConstants[145] = ceil(constants[1]); + computedConstants[146] = floor(constants[1]); + computedConstants[147] = min(constants[1], constants[2]); + computedConstants[148] = min(constants[1], min(constants[2], constants[6])); + computedConstants[149] = max(constants[1], constants[2]); + computedConstants[150] = max(constants[1], max(constants[2], constants[6])); + computedConstants[151] = fmod(constants[1], constants[2]); + computedConstants[152] = sin(constants[1]); + computedConstants[153] = cos(constants[1]); + computedConstants[154] = tan(constants[1]); + computedConstants[155] = sec(constants[1]); + computedConstants[156] = csc(constants[1]); + computedConstants[157] = cot(constants[1]); + computedConstants[158] = sinh(constants[1]); + computedConstants[159] = cosh(constants[1]); + computedConstants[160] = tanh(constants[1]); + computedConstants[161] = sech(constants[1]); + computedConstants[162] = csch(constants[1]); + computedConstants[163] = coth(constants[1]); + computedConstants[164] = asin(constants[1]); + computedConstants[165] = acos(constants[1]); + computedConstants[166] = atan(constants[1]); + computedConstants[167] = asec(constants[1]); + computedConstants[168] = acsc(constants[1]); + computedConstants[169] = acot(constants[1]); + computedConstants[170] = asinh(constants[1]); + computedConstants[171] = acosh(constants[1]); + computedConstants[172] = atanh(constants[1]/2.0); + computedConstants[173] = asech(constants[1]); + computedConstants[174] = acsch(constants[1]); + computedConstants[175] = acoth(2.0*constants[1]); + computedConstants[176] = piecewise(constants[1] > constants[2], constants[1], NAN); + computedConstants[177] = piecewise(constants[1] > constants[2], constants[1], constants[6]); + computedConstants[178] = piecewise(constants[1] > constants[2], constants[1], piecewise(constants[6] > constants[18], constants[6], piecewise(constants[179] > constants[180], constants[179], NAN))); + computedConstants[181] = piecewise(constants[1] > constants[2], constants[1], piecewise(constants[6] > constants[18], constants[6], piecewise(constants[179] > constants[180], constants[179], constants[182]))); + computedConstants[183] = 123.0+piecewise(constants[1] > constants[2], constants[1], NAN); + computedConstants[188] = constants[1]; + computedConstants[195] = (constants[1] && constants[2])+piecewise(constants[6] > constants[18], constants[2], NAN)+constants[179]+(constants[180] && constants[182]); + computedConstants[196] = (constants[1] && constants[2])-(piecewise(constants[6] > constants[18], constants[2], NAN)-(constants[179]-piecewise(constants[6] > constants[18], constants[2], NAN)))-(constants[180] && constants[182]); + computedConstants[197] = (constants[1] && constants[2])*piecewise(constants[6] > constants[18], constants[2], NAN)*constants[179]*piecewise(constants[6] > constants[18], constants[2], NAN)*(constants[180] && constants[182]); + computedConstants[198] = (constants[1] && constants[2])/(piecewise(constants[6] > constants[18], constants[2], NAN)/(constants[179]/piecewise(constants[6] > constants[18], constants[2], NAN))); + computedConstants[199] = (constants[1] || constants[2]) && (constants[1]^constants[2]) && piecewise(constants[6] > constants[18], constants[2], NAN) && constants[179] && piecewise(constants[6] > constants[18], constants[2], NAN) && (constants[1]^constants[2]) && (constants[1] || constants[2]); + computedConstants[200] = (constants[1] && constants[2]) || (constants[1]^constants[2]) || piecewise(constants[6] > constants[18], constants[2], NAN) || constants[179] || piecewise(constants[6] > constants[18], constants[2], NAN) || (constants[1]^constants[2]) || (constants[1] && constants[2]); + computedConstants[201] = (constants[1] && constants[2])^(constants[1] || constants[2])^piecewise(constants[6] > constants[18], constants[2], NAN)^constants[179]^piecewise(constants[6] > constants[18], constants[2], NAN)^(constants[1] || constants[2])^(constants[1] && constants[2]); + computedConstants[202] = (constants[1] && constants[2])^^(piecewise(constants[6] > constants[18], constants[2], NAN)^^(constants[179]^^piecewise(constants[6] > constants[18], constants[2], NAN)^^(constants[1] && constants[2]))); + computedConstants[203] = (constants[1] && constants[2])^^(1.0/(piecewise(constants[6] > constants[18], constants[2], NAN)^^(1.0/constants[179])))^^(1.0/piecewise(constants[6] > constants[18], constants[2], NAN))^^(1.0/(constants[1] && constants[2])); + computedConstants[204] = -(constants[1] && constants[2])+-piecewise(constants[6] > constants[18], constants[2], NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 1a6049e40..acbe541a5 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -359,239 +359,239 @@ def objective_function_0(u, f, data): rates = data[2] variables = data[3] - variables[205] = u[0] - variables[206] = u[1] + algebraic[205] = u[0] + algebraic[206] = u[1] - f[0] = variables[205]+variables[206]+states[0]-0.0 - f[1] = variables[205]-variables[206]-(variables[207]+variables[208]) + f[0] = algebraic[205]+algebraic[206]+states[0]-0.0 + f[1] = algebraic[205]-algebraic[206]-(computed_constants[207]+computed_constants[208]) def find_root_0(voi, states, rates, variables): u = [nan]*2 - u[0] = variables[205] - u[1] = variables[206] + u[0] = algebraic[205] + u[1] = algebraic[206] u = nla_solve(objective_function_0, u, 2, [voi, states, rates, variables]) - variables[205] = u[0] - variables[206] = u[1] + algebraic[205] = u[0] + algebraic[206] = u[1] def initialise_variables(states, rates, constants): - variables[1] = 1.0 - variables[2] = 2.0 - variables[6] = 3.0 - variables[18] = 4.0 - variables[179] = 5.0 - variables[180] = 6.0 - variables[182] = 7.0 - variables[205] = 1.0 - variables[206] = 2.0 - variables[184] = 123.0 - variables[185] = 123.456789 - variables[186] = 123.0e99 - variables[187] = 123.456789e99 - variables[189] = 1.0 - variables[190] = 0.0 - variables[191] = 2.71828182845905 - variables[192] = 3.14159265358979 - variables[193] = inf - variables[194] = nan - variables[207] = 1.0 - variables[208] = 3.0 + constants[1] = 1.0 + constants[2] = 2.0 + constants[6] = 3.0 + constants[18] = 4.0 + constants[179] = 5.0 + constants[180] = 6.0 + constants[182] = 7.0 + algebraic[205] = 1.0 + algebraic[206] = 2.0 + computed_constants[184] = 123.0 + computed_constants[185] = 123.456789 + computed_constants[186] = 123.0e99 + computed_constants[187] = 123.456789e99 + computed_constants[189] = 1.0 + computed_constants[190] = 0.0 + computed_constants[191] = 2.71828182845905 + computed_constants[192] = 3.14159265358979 + computed_constants[193] = inf + computed_constants[194] = nan + computed_constants[207] = 1.0 + computed_constants[208] = 3.0 states[0] = 0.0 def compute_computed_constants(constants, computed_constants): - variables[0] = eq_func(variables[1], variables[2]) - variables[3] = variables[1]/eq_func(variables[2], variables[2]) - variables[4] = neq_func(variables[1], variables[2]) - variables[5] = variables[1]/neq_func(variables[2], variables[6]) - variables[7] = lt_func(variables[1], variables[2]) - variables[8] = variables[1]/lt_func(variables[2], variables[6]) - variables[9] = leq_func(variables[1], variables[2]) - variables[10] = variables[1]/leq_func(variables[2], variables[6]) - variables[11] = gt_func(variables[1], variables[2]) - variables[12] = variables[1]/gt_func(variables[2], variables[6]) - variables[13] = geq_func(variables[1], variables[2]) - variables[14] = variables[1]/geq_func(variables[2], variables[6]) - variables[15] = and_func(variables[1], variables[2]) - variables[16] = and_func(variables[1], and_func(variables[2], variables[6])) - variables[17] = and_func(lt_func(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[19] = and_func(variables[1]+variables[2], gt_func(variables[6], variables[18])) - variables[20] = and_func(variables[1], gt_func(variables[2], variables[6])) - variables[21] = and_func(variables[1]-variables[2], gt_func(variables[6], variables[18])) - variables[22] = and_func(-variables[1], gt_func(variables[2], variables[6])) - variables[23] = and_func(pow(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[24] = and_func(pow(variables[1], 1.0/variables[2]), gt_func(variables[6], variables[18])) - variables[25] = and_func(lt_func(variables[1], variables[2]), variables[6]+variables[18]) - variables[26] = and_func(lt_func(variables[1], variables[2]), variables[6]) - variables[27] = and_func(lt_func(variables[1], variables[2]), variables[6]-variables[18]) - variables[28] = and_func(lt_func(variables[1], variables[2]), -variables[6]) - variables[29] = and_func(lt_func(variables[1], variables[2]), pow(variables[6], variables[18])) - variables[30] = and_func(lt_func(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])) - variables[31] = variables[1]/and_func(variables[2], variables[6]) - variables[32] = or_func(variables[1], variables[2]) - variables[33] = or_func(variables[1], or_func(variables[2], variables[6])) - variables[34] = or_func(lt_func(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[35] = or_func(variables[1]+variables[2], gt_func(variables[6], variables[18])) - variables[36] = or_func(variables[1], gt_func(variables[2], variables[6])) - variables[37] = or_func(variables[1]-variables[2], gt_func(variables[6], variables[18])) - variables[38] = or_func(-variables[1], gt_func(variables[2], variables[6])) - variables[39] = or_func(pow(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[40] = or_func(pow(variables[1], 1.0/variables[2]), gt_func(variables[6], variables[18])) - variables[41] = or_func(lt_func(variables[1], variables[2]), variables[6]+variables[18]) - variables[42] = or_func(lt_func(variables[1], variables[2]), variables[6]) - variables[43] = or_func(lt_func(variables[1], variables[2]), variables[6]-variables[18]) - variables[44] = or_func(lt_func(variables[1], variables[2]), -variables[6]) - variables[45] = or_func(lt_func(variables[1], variables[2]), pow(variables[6], variables[18])) - variables[46] = or_func(lt_func(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])) - variables[47] = variables[1]/or_func(variables[2], variables[6]) - variables[48] = xor_func(variables[1], variables[2]) - variables[49] = xor_func(variables[1], xor_func(variables[2], variables[6])) - variables[50] = xor_func(lt_func(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[51] = xor_func(variables[1]+variables[2], gt_func(variables[6], variables[18])) - variables[52] = xor_func(variables[1], gt_func(variables[2], variables[6])) - variables[53] = xor_func(variables[1]-variables[2], gt_func(variables[6], variables[18])) - variables[54] = xor_func(-variables[1], gt_func(variables[2], variables[6])) - variables[55] = xor_func(pow(variables[1], variables[2]), gt_func(variables[6], variables[18])) - variables[56] = xor_func(pow(variables[1], 1.0/variables[2]), gt_func(variables[6], variables[18])) - variables[57] = xor_func(lt_func(variables[1], variables[2]), variables[6]+variables[18]) - variables[58] = xor_func(lt_func(variables[1], variables[2]), variables[6]) - variables[59] = xor_func(lt_func(variables[1], variables[2]), variables[6]-variables[18]) - variables[60] = xor_func(lt_func(variables[1], variables[2]), -variables[6]) - variables[61] = xor_func(lt_func(variables[1], variables[2]), pow(variables[6], variables[18])) - variables[62] = xor_func(lt_func(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])) - variables[63] = variables[1]/xor_func(variables[2], variables[6]) - variables[64] = not_func(variables[1]) - variables[65] = variables[1]+variables[2] - variables[66] = variables[1]+variables[2]+variables[6] - variables[67] = lt_func(variables[1], variables[2])+gt_func(variables[6], variables[18]) - variables[68] = variables[1] - variables[69] = variables[1]-variables[2] - variables[70] = lt_func(variables[1], variables[2])-gt_func(variables[6], variables[18]) - variables[71] = lt_func(variables[1], variables[2])-(variables[6]+variables[18]) - variables[72] = lt_func(variables[1], variables[2])-variables[6] - variables[73] = variables[1]-(-variables[2]) - variables[74] = variables[1]-(-variables[2]*variables[6]) - variables[75] = -variables[1] - variables[76] = -lt_func(variables[1], variables[2]) - variables[77] = variables[1]*variables[2] - variables[78] = variables[1]*variables[2]*variables[6] - variables[79] = lt_func(variables[1], variables[2])*gt_func(variables[6], variables[18]) - variables[80] = (variables[1]+variables[2])*gt_func(variables[6], variables[18]) - variables[81] = variables[1]*gt_func(variables[2], variables[6]) - variables[82] = (variables[1]-variables[2])*gt_func(variables[6], variables[18]) - variables[83] = -variables[1]*gt_func(variables[2], variables[6]) - variables[84] = lt_func(variables[1], variables[2])*(variables[6]+variables[18]) - variables[85] = lt_func(variables[1], variables[2])*variables[6] - variables[86] = lt_func(variables[1], variables[2])*(variables[6]-variables[18]) - variables[87] = lt_func(variables[1], variables[2])*-variables[6] - variables[88] = variables[1]/variables[2] - variables[89] = lt_func(variables[1], variables[2])/gt_func(variables[18], variables[6]) - variables[90] = (variables[1]+variables[2])/gt_func(variables[18], variables[6]) - variables[91] = variables[1]/gt_func(variables[6], variables[2]) - variables[92] = (variables[1]-variables[2])/gt_func(variables[18], variables[6]) - variables[93] = -variables[1]/gt_func(variables[6], variables[2]) - variables[94] = lt_func(variables[1], variables[2])/(variables[6]+variables[18]) - variables[95] = lt_func(variables[1], variables[2])/variables[6] - variables[96] = lt_func(variables[1], variables[2])/(variables[6]-variables[18]) - variables[97] = lt_func(variables[1], variables[2])/-variables[6] - variables[98] = lt_func(variables[1], variables[2])/(variables[6]*variables[18]) - variables[99] = lt_func(variables[1], variables[2])/(variables[6]/variables[18]) - variables[100] = sqrt(variables[1]) - variables[101] = pow(variables[1], 2.0) - variables[102] = pow(variables[1], 3.0) - variables[103] = pow(variables[1], variables[2]) - variables[104] = pow(leq_func(variables[1], variables[2]), geq_func(variables[6], variables[18])) - variables[105] = pow(variables[1]+variables[2], geq_func(variables[6], variables[18])) - variables[106] = pow(variables[1], geq_func(variables[2], variables[6])) - variables[107] = pow(variables[1]-variables[2], geq_func(variables[6], variables[18])) - variables[108] = pow(-variables[1], geq_func(variables[2], variables[6])) - variables[109] = pow(variables[1]*variables[2], geq_func(variables[6], variables[18])) - variables[110] = pow(variables[1]/variables[2], geq_func(variables[6], variables[18])) - variables[111] = pow(leq_func(variables[1], variables[2]), variables[6]+variables[18]) - variables[112] = pow(leq_func(variables[1], variables[2]), variables[6]) - variables[113] = pow(leq_func(variables[1], variables[2]), variables[6]-variables[18]) - variables[114] = pow(leq_func(variables[1], variables[2]), -variables[6]) - variables[115] = pow(leq_func(variables[1], variables[2]), variables[6]*variables[18]) - variables[116] = pow(leq_func(variables[1], variables[2]), variables[6]/variables[18]) - variables[117] = pow(leq_func(variables[1], variables[2]), pow(variables[6], variables[18])) - variables[118] = pow(leq_func(variables[1], variables[2]), pow(variables[6], 1.0/variables[18])) - variables[119] = sqrt(variables[1]) - variables[120] = sqrt(variables[1]) - variables[121] = pow(variables[1], 1.0/3.0) - variables[122] = pow(variables[1], 1.0/variables[2]) - variables[123] = pow(lt_func(variables[1], variables[2]), 1.0/gt_func(variables[18], variables[6])) - variables[124] = pow(variables[1]+variables[2], 1.0/gt_func(variables[18], variables[6])) - variables[125] = pow(variables[1], 1.0/gt_func(variables[6], variables[2])) - variables[126] = pow(variables[1]-variables[2], 1.0/gt_func(variables[18], variables[6])) - variables[127] = pow(-variables[1], 1.0/gt_func(variables[6], variables[2])) - variables[128] = pow(variables[1]*variables[2], 1.0/gt_func(variables[18], variables[6])) - variables[129] = pow(variables[1]/variables[2], 1.0/gt_func(variables[18], variables[6])) - variables[130] = pow(lt_func(variables[1], variables[2]), 1.0/(variables[6]+variables[18])) - variables[131] = pow(lt_func(variables[1], variables[2]), 1.0/variables[6]) - variables[132] = pow(lt_func(variables[1], variables[2]), 1.0/(variables[6]-variables[18])) - variables[133] = pow(lt_func(variables[1], variables[2]), 1.0/-variables[6]) - variables[134] = pow(lt_func(variables[1], variables[2]), 1.0/(variables[6]*variables[18])) - variables[135] = pow(lt_func(variables[1], variables[2]), 1.0/(variables[6]/variables[18])) - variables[136] = pow(lt_func(variables[1], variables[2]), 1.0/pow(variables[6], variables[18])) - variables[137] = pow(lt_func(variables[1], variables[2]), 1.0/pow(variables[6], 1.0/variables[18])) - variables[138] = fabs(variables[1]) - variables[139] = exp(variables[1]) - variables[140] = log(variables[1]) - variables[141] = log10(variables[1]) - variables[142] = log(variables[1])/log(2.0) - variables[143] = log10(variables[1]) - variables[144] = log(variables[1])/log(variables[2]) - variables[145] = ceil(variables[1]) - variables[146] = floor(variables[1]) - variables[147] = min(variables[1], variables[2]) - variables[148] = min(variables[1], min(variables[2], variables[6])) - variables[149] = max(variables[1], variables[2]) - variables[150] = max(variables[1], max(variables[2], variables[6])) - variables[151] = fmod(variables[1], variables[2]) - variables[152] = sin(variables[1]) - variables[153] = cos(variables[1]) - variables[154] = tan(variables[1]) - variables[155] = sec(variables[1]) - variables[156] = csc(variables[1]) - variables[157] = cot(variables[1]) - variables[158] = sinh(variables[1]) - variables[159] = cosh(variables[1]) - variables[160] = tanh(variables[1]) - variables[161] = sech(variables[1]) - variables[162] = csch(variables[1]) - variables[163] = coth(variables[1]) - variables[164] = asin(variables[1]) - variables[165] = acos(variables[1]) - variables[166] = atan(variables[1]) - variables[167] = asec(variables[1]) - variables[168] = acsc(variables[1]) - variables[169] = acot(variables[1]) - variables[170] = asinh(variables[1]) - variables[171] = acosh(variables[1]) - variables[172] = atanh(variables[1]/2.0) - variables[173] = asech(variables[1]) - variables[174] = acsch(variables[1]) - variables[175] = acoth(2.0*variables[1]) - variables[176] = variables[1] if gt_func(variables[1], variables[2]) else nan - variables[177] = variables[1] if gt_func(variables[1], variables[2]) else variables[6] - variables[178] = variables[1] if gt_func(variables[1], variables[2]) else variables[6] if gt_func(variables[6], variables[18]) else variables[179] if gt_func(variables[179], variables[180]) else nan - variables[181] = variables[1] if gt_func(variables[1], variables[2]) else variables[6] if gt_func(variables[6], variables[18]) else variables[179] if gt_func(variables[179], variables[180]) else variables[182] - variables[183] = 123.0+(variables[1] if gt_func(variables[1], variables[2]) else nan) - variables[188] = variables[1] - variables[195] = and_func(variables[1], variables[2])+(variables[2] if gt_func(variables[6], variables[18]) else nan)+variables[179]+and_func(variables[180], variables[182]) - variables[196] = and_func(variables[1], variables[2])-((variables[2] if gt_func(variables[6], variables[18]) else nan)-(variables[179]-(variables[2] if gt_func(variables[6], variables[18]) else nan)))-and_func(variables[180], variables[182]) - variables[197] = and_func(variables[1], variables[2])*(variables[2] if gt_func(variables[6], variables[18]) else nan)*variables[179]*(variables[2] if gt_func(variables[6], variables[18]) else nan)*and_func(variables[180], variables[182]) - variables[198] = and_func(variables[1], variables[2])/((variables[2] if gt_func(variables[6], variables[18]) else nan)/(variables[179]/(variables[2] if gt_func(variables[6], variables[18]) else nan))) - variables[199] = and_func(or_func(variables[1], variables[2]), and_func(xor_func(variables[1], variables[2]), and_func(variables[2] if gt_func(variables[6], variables[18]) else nan, and_func(and_func(and_func(variables[179], variables[2] if gt_func(variables[6], variables[18]) else nan), xor_func(variables[1], variables[2])), or_func(variables[1], variables[2]))))) - variables[200] = or_func(and_func(variables[1], variables[2]), or_func(xor_func(variables[1], variables[2]), or_func(variables[2] if gt_func(variables[6], variables[18]) else nan, or_func(or_func(or_func(variables[179], variables[2] if gt_func(variables[6], variables[18]) else nan), xor_func(variables[1], variables[2])), and_func(variables[1], variables[2]))))) - variables[201] = xor_func(and_func(variables[1], variables[2]), xor_func(or_func(variables[1], variables[2]), xor_func(variables[2] if gt_func(variables[6], variables[18]) else nan, xor_func(xor_func(xor_func(variables[179], variables[2] if gt_func(variables[6], variables[18]) else nan), or_func(variables[1], variables[2])), and_func(variables[1], variables[2]))))) - variables[202] = pow(and_func(variables[1], variables[2]), pow(variables[2] if gt_func(variables[6], variables[18]) else nan, pow(pow(variables[179], variables[2] if gt_func(variables[6], variables[18]) else nan), and_func(variables[1], variables[2])))) - variables[203] = pow(pow(pow(and_func(variables[1], variables[2]), 1.0/pow(variables[2] if gt_func(variables[6], variables[18]) else nan, 1.0/variables[179])), 1.0/(variables[2] if gt_func(variables[6], variables[18]) else nan)), 1.0/and_func(variables[1], variables[2])) - variables[204] = -and_func(variables[1], variables[2])+-(variables[2] if gt_func(variables[6], variables[18]) else nan) + computed_constants[0] = eq_func(constants[1], constants[2]) + computed_constants[3] = constants[1]/eq_func(constants[2], constants[2]) + computed_constants[4] = neq_func(constants[1], constants[2]) + computed_constants[5] = constants[1]/neq_func(constants[2], constants[6]) + computed_constants[7] = lt_func(constants[1], constants[2]) + computed_constants[8] = constants[1]/lt_func(constants[2], constants[6]) + computed_constants[9] = leq_func(constants[1], constants[2]) + computed_constants[10] = constants[1]/leq_func(constants[2], constants[6]) + computed_constants[11] = gt_func(constants[1], constants[2]) + computed_constants[12] = constants[1]/gt_func(constants[2], constants[6]) + computed_constants[13] = geq_func(constants[1], constants[2]) + computed_constants[14] = constants[1]/geq_func(constants[2], constants[6]) + computed_constants[15] = and_func(constants[1], constants[2]) + computed_constants[16] = and_func(constants[1], and_func(constants[2], constants[6])) + computed_constants[17] = and_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[19] = and_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) + computed_constants[20] = and_func(constants[1], gt_func(constants[2], constants[6])) + computed_constants[21] = and_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) + computed_constants[22] = and_func(-constants[1], gt_func(constants[2], constants[6])) + computed_constants[23] = and_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[24] = and_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) + computed_constants[25] = and_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) + computed_constants[26] = and_func(lt_func(constants[1], constants[2]), constants[6]) + computed_constants[27] = and_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) + computed_constants[28] = and_func(lt_func(constants[1], constants[2]), -constants[6]) + computed_constants[29] = and_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) + computed_constants[30] = and_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) + computed_constants[31] = constants[1]/and_func(constants[2], constants[6]) + computed_constants[32] = or_func(constants[1], constants[2]) + computed_constants[33] = or_func(constants[1], or_func(constants[2], constants[6])) + computed_constants[34] = or_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[35] = or_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) + computed_constants[36] = or_func(constants[1], gt_func(constants[2], constants[6])) + computed_constants[37] = or_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) + computed_constants[38] = or_func(-constants[1], gt_func(constants[2], constants[6])) + computed_constants[39] = or_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[40] = or_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) + computed_constants[41] = or_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) + computed_constants[42] = or_func(lt_func(constants[1], constants[2]), constants[6]) + computed_constants[43] = or_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) + computed_constants[44] = or_func(lt_func(constants[1], constants[2]), -constants[6]) + computed_constants[45] = or_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) + computed_constants[46] = or_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) + computed_constants[47] = constants[1]/or_func(constants[2], constants[6]) + computed_constants[48] = xor_func(constants[1], constants[2]) + computed_constants[49] = xor_func(constants[1], xor_func(constants[2], constants[6])) + computed_constants[50] = xor_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[51] = xor_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) + computed_constants[52] = xor_func(constants[1], gt_func(constants[2], constants[6])) + computed_constants[53] = xor_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) + computed_constants[54] = xor_func(-constants[1], gt_func(constants[2], constants[6])) + computed_constants[55] = xor_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) + computed_constants[56] = xor_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) + computed_constants[57] = xor_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) + computed_constants[58] = xor_func(lt_func(constants[1], constants[2]), constants[6]) + computed_constants[59] = xor_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) + computed_constants[60] = xor_func(lt_func(constants[1], constants[2]), -constants[6]) + computed_constants[61] = xor_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) + computed_constants[62] = xor_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) + computed_constants[63] = constants[1]/xor_func(constants[2], constants[6]) + computed_constants[64] = not_func(constants[1]) + computed_constants[65] = constants[1]+constants[2] + computed_constants[66] = constants[1]+constants[2]+constants[6] + computed_constants[67] = lt_func(constants[1], constants[2])+gt_func(constants[6], constants[18]) + computed_constants[68] = constants[1] + computed_constants[69] = constants[1]-constants[2] + computed_constants[70] = lt_func(constants[1], constants[2])-gt_func(constants[6], constants[18]) + computed_constants[71] = lt_func(constants[1], constants[2])-(constants[6]+constants[18]) + computed_constants[72] = lt_func(constants[1], constants[2])-constants[6] + computed_constants[73] = constants[1]-(-constants[2]) + computed_constants[74] = constants[1]-(-constants[2]*constants[6]) + computed_constants[75] = -constants[1] + computed_constants[76] = -lt_func(constants[1], constants[2]) + computed_constants[77] = constants[1]*constants[2] + computed_constants[78] = constants[1]*constants[2]*constants[6] + computed_constants[79] = lt_func(constants[1], constants[2])*gt_func(constants[6], constants[18]) + computed_constants[80] = (constants[1]+constants[2])*gt_func(constants[6], constants[18]) + computed_constants[81] = constants[1]*gt_func(constants[2], constants[6]) + computed_constants[82] = (constants[1]-constants[2])*gt_func(constants[6], constants[18]) + computed_constants[83] = -constants[1]*gt_func(constants[2], constants[6]) + computed_constants[84] = lt_func(constants[1], constants[2])*(constants[6]+constants[18]) + computed_constants[85] = lt_func(constants[1], constants[2])*constants[6] + computed_constants[86] = lt_func(constants[1], constants[2])*(constants[6]-constants[18]) + computed_constants[87] = lt_func(constants[1], constants[2])*-constants[6] + computed_constants[88] = constants[1]/constants[2] + computed_constants[89] = lt_func(constants[1], constants[2])/gt_func(constants[18], constants[6]) + computed_constants[90] = (constants[1]+constants[2])/gt_func(constants[18], constants[6]) + computed_constants[91] = constants[1]/gt_func(constants[6], constants[2]) + computed_constants[92] = (constants[1]-constants[2])/gt_func(constants[18], constants[6]) + computed_constants[93] = -constants[1]/gt_func(constants[6], constants[2]) + computed_constants[94] = lt_func(constants[1], constants[2])/(constants[6]+constants[18]) + computed_constants[95] = lt_func(constants[1], constants[2])/constants[6] + computed_constants[96] = lt_func(constants[1], constants[2])/(constants[6]-constants[18]) + computed_constants[97] = lt_func(constants[1], constants[2])/-constants[6] + computed_constants[98] = lt_func(constants[1], constants[2])/(constants[6]*constants[18]) + computed_constants[99] = lt_func(constants[1], constants[2])/(constants[6]/constants[18]) + computed_constants[100] = sqrt(constants[1]) + computed_constants[101] = pow(constants[1], 2.0) + computed_constants[102] = pow(constants[1], 3.0) + computed_constants[103] = pow(constants[1], constants[2]) + computed_constants[104] = pow(leq_func(constants[1], constants[2]), geq_func(constants[6], constants[18])) + computed_constants[105] = pow(constants[1]+constants[2], geq_func(constants[6], constants[18])) + computed_constants[106] = pow(constants[1], geq_func(constants[2], constants[6])) + computed_constants[107] = pow(constants[1]-constants[2], geq_func(constants[6], constants[18])) + computed_constants[108] = pow(-constants[1], geq_func(constants[2], constants[6])) + computed_constants[109] = pow(constants[1]*constants[2], geq_func(constants[6], constants[18])) + computed_constants[110] = pow(constants[1]/constants[2], geq_func(constants[6], constants[18])) + computed_constants[111] = pow(leq_func(constants[1], constants[2]), constants[6]+constants[18]) + computed_constants[112] = pow(leq_func(constants[1], constants[2]), constants[6]) + computed_constants[113] = pow(leq_func(constants[1], constants[2]), constants[6]-constants[18]) + computed_constants[114] = pow(leq_func(constants[1], constants[2]), -constants[6]) + computed_constants[115] = pow(leq_func(constants[1], constants[2]), constants[6]*constants[18]) + computed_constants[116] = pow(leq_func(constants[1], constants[2]), constants[6]/constants[18]) + computed_constants[117] = pow(leq_func(constants[1], constants[2]), pow(constants[6], constants[18])) + computed_constants[118] = pow(leq_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) + computed_constants[119] = sqrt(constants[1]) + computed_constants[120] = sqrt(constants[1]) + computed_constants[121] = pow(constants[1], 1.0/3.0) + computed_constants[122] = pow(constants[1], 1.0/constants[2]) + computed_constants[123] = pow(lt_func(constants[1], constants[2]), 1.0/gt_func(constants[18], constants[6])) + computed_constants[124] = pow(constants[1]+constants[2], 1.0/gt_func(constants[18], constants[6])) + computed_constants[125] = pow(constants[1], 1.0/gt_func(constants[6], constants[2])) + computed_constants[126] = pow(constants[1]-constants[2], 1.0/gt_func(constants[18], constants[6])) + computed_constants[127] = pow(-constants[1], 1.0/gt_func(constants[6], constants[2])) + computed_constants[128] = pow(constants[1]*constants[2], 1.0/gt_func(constants[18], constants[6])) + computed_constants[129] = pow(constants[1]/constants[2], 1.0/gt_func(constants[18], constants[6])) + computed_constants[130] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]+constants[18])) + computed_constants[131] = pow(lt_func(constants[1], constants[2]), 1.0/constants[6]) + computed_constants[132] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]-constants[18])) + computed_constants[133] = pow(lt_func(constants[1], constants[2]), 1.0/-constants[6]) + computed_constants[134] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]*constants[18])) + computed_constants[135] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]/constants[18])) + computed_constants[136] = pow(lt_func(constants[1], constants[2]), 1.0/pow(constants[6], constants[18])) + computed_constants[137] = pow(lt_func(constants[1], constants[2]), 1.0/pow(constants[6], 1.0/constants[18])) + computed_constants[138] = fabs(constants[1]) + computed_constants[139] = exp(constants[1]) + computed_constants[140] = log(constants[1]) + computed_constants[141] = log10(constants[1]) + computed_constants[142] = log(constants[1])/log(2.0) + computed_constants[143] = log10(constants[1]) + computed_constants[144] = log(constants[1])/log(constants[2]) + computed_constants[145] = ceil(constants[1]) + computed_constants[146] = floor(constants[1]) + computed_constants[147] = min(constants[1], constants[2]) + computed_constants[148] = min(constants[1], min(constants[2], constants[6])) + computed_constants[149] = max(constants[1], constants[2]) + computed_constants[150] = max(constants[1], max(constants[2], constants[6])) + computed_constants[151] = fmod(constants[1], constants[2]) + computed_constants[152] = sin(constants[1]) + computed_constants[153] = cos(constants[1]) + computed_constants[154] = tan(constants[1]) + computed_constants[155] = sec(constants[1]) + computed_constants[156] = csc(constants[1]) + computed_constants[157] = cot(constants[1]) + computed_constants[158] = sinh(constants[1]) + computed_constants[159] = cosh(constants[1]) + computed_constants[160] = tanh(constants[1]) + computed_constants[161] = sech(constants[1]) + computed_constants[162] = csch(constants[1]) + computed_constants[163] = coth(constants[1]) + computed_constants[164] = asin(constants[1]) + computed_constants[165] = acos(constants[1]) + computed_constants[166] = atan(constants[1]) + computed_constants[167] = asec(constants[1]) + computed_constants[168] = acsc(constants[1]) + computed_constants[169] = acot(constants[1]) + computed_constants[170] = asinh(constants[1]) + computed_constants[171] = acosh(constants[1]) + computed_constants[172] = atanh(constants[1]/2.0) + computed_constants[173] = asech(constants[1]) + computed_constants[174] = acsch(constants[1]) + computed_constants[175] = acoth(2.0*constants[1]) + computed_constants[176] = constants[1] if gt_func(constants[1], constants[2]) else nan + computed_constants[177] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] + computed_constants[178] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] if gt_func(constants[6], constants[18]) else constants[179] if gt_func(constants[179], constants[180]) else nan + computed_constants[181] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] if gt_func(constants[6], constants[18]) else constants[179] if gt_func(constants[179], constants[180]) else constants[182] + computed_constants[183] = 123.0+(constants[1] if gt_func(constants[1], constants[2]) else nan) + computed_constants[188] = constants[1] + computed_constants[195] = and_func(constants[1], constants[2])+(constants[2] if gt_func(constants[6], constants[18]) else nan)+constants[179]+and_func(constants[180], constants[182]) + computed_constants[196] = and_func(constants[1], constants[2])-((constants[2] if gt_func(constants[6], constants[18]) else nan)-(constants[179]-(constants[2] if gt_func(constants[6], constants[18]) else nan)))-and_func(constants[180], constants[182]) + computed_constants[197] = and_func(constants[1], constants[2])*(constants[2] if gt_func(constants[6], constants[18]) else nan)*constants[179]*(constants[2] if gt_func(constants[6], constants[18]) else nan)*and_func(constants[180], constants[182]) + computed_constants[198] = and_func(constants[1], constants[2])/((constants[2] if gt_func(constants[6], constants[18]) else nan)/(constants[179]/(constants[2] if gt_func(constants[6], constants[18]) else nan))) + computed_constants[199] = and_func(or_func(constants[1], constants[2]), and_func(xor_func(constants[1], constants[2]), and_func(constants[2] if gt_func(constants[6], constants[18]) else nan, and_func(and_func(and_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), xor_func(constants[1], constants[2])), or_func(constants[1], constants[2]))))) + computed_constants[200] = or_func(and_func(constants[1], constants[2]), or_func(xor_func(constants[1], constants[2]), or_func(constants[2] if gt_func(constants[6], constants[18]) else nan, or_func(or_func(or_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), xor_func(constants[1], constants[2])), and_func(constants[1], constants[2]))))) + computed_constants[201] = xor_func(and_func(constants[1], constants[2]), xor_func(or_func(constants[1], constants[2]), xor_func(constants[2] if gt_func(constants[6], constants[18]) else nan, xor_func(xor_func(xor_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), or_func(constants[1], constants[2])), and_func(constants[1], constants[2]))))) + computed_constants[202] = pow(and_func(constants[1], constants[2]), pow(constants[2] if gt_func(constants[6], constants[18]) else nan, pow(pow(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), and_func(constants[1], constants[2])))) + computed_constants[203] = pow(pow(pow(and_func(constants[1], constants[2]), 1.0/pow(constants[2] if gt_func(constants[6], constants[18]) else nan, 1.0/constants[179])), 1.0/(constants[2] if gt_func(constants[6], constants[18]) else nan)), 1.0/and_func(constants[1], constants[2])) + computed_constants[204] = -and_func(constants[1], constants[2])+-(constants[2] if gt_func(constants[6], constants[18]) else nan) def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index 42f15c79b..8eee3cf3a 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -35,12 +35,12 @@ void deleteArray(double *array) void initialiseVariables(double *constants) { - variables[1] = 1.0; + computedConstants[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - variables[0] = variables[1]; + computedConstants[0] = computedConstants[1]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 8cbf6bf05..e3f909a3f 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -35,7 +35,7 @@ void deleteArray(double *array) void initialiseVariables(double *constants, ExternalVariable externalVariable) { - variables[1] = externalVariable(variables, 1); + algebraic[1] = externalVariable(variables, 1); } void computeComputedConstants(double *constants, double *computedConstants) @@ -44,6 +44,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[1] = externalVariable(variables, 1); - variables[0] = variables[1]; + algebraic[1] = externalVariable(variables, 1); + algebraic[0] = algebraic[1]; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 2670115d4..830a7dbcc 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -30,7 +30,7 @@ def create_variables_array(): def initialise_variables(constants, external_variable): - variables[1] = external_variable(variables, 1) + algebraic[1] = external_variable(variables, 1) def compute_computed_constants(constants, computed_constants): @@ -38,5 +38,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - variables[1] = external_variable(variables, 1) - variables[0] = variables[1] + algebraic[1] = external_variable(variables, 1) + algebraic[0] = algebraic[1] diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index 24d09dbb1..abbf71111 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -29,11 +29,11 @@ def create_variables_array(): def initialise_variables(constants): - variables[1] = 1.0 + computed_constants[1] = 1.0 def compute_computed_constants(constants, computed_constants): - variables[0] = variables[1] + computed_constants[0] = computed_constants[1] def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index dc50dc17e..662430389 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -35,12 +35,12 @@ void deleteArray(double *array) void initialiseVariables(double *constants) { - variables[1] = 1.0; + constants[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - variables[0] = variables[1]; + computedConstants[0] = constants[1]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index 305a6e7fd..9b07f9502 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -29,11 +29,11 @@ def create_variables_array(): def initialise_variables(constants): - variables[1] = 1.0 + constants[1] = 1.0 def compute_computed_constants(constants, computed_constants): - variables[0] = variables[1] + computed_constants[0] = constants[1] def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index 5e1791ae7..89a7cc42a 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -34,7 +34,7 @@ void deleteArray(double *array) void initialiseVariables(double *constants) { - variables[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index 461c24647..bbee07879 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -28,7 +28,7 @@ def create_variables_array(): def initialise_variables(constants): - variables[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index c37ec4154..c08dde32e 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -53,7 +53,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 1.0; + computedConstants[0] = 1.0; states[0] = 1.0; } @@ -63,10 +63,10 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = variables[0]; + rates[0] = computedConstants[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[1] = rates[0]; + algebraic[1] = rates[0]; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index dcdeee9d7..5e2901ca3 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -42,7 +42,7 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 1.0 + computed_constants[0] = 1.0 states[0] = 1.0 @@ -51,8 +51,8 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = variables[0] + rates[0] = computed_constants[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[1] = rates[0] + algebraic[1] = rates[0] diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 360d5cdaf..5d3967ab0 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -53,7 +53,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 1.0; + computedConstants[0] = 1.0; states[0] = 1.0; } @@ -63,10 +63,10 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = variables[0]; + rates[0] = computedConstants[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[1] = rates[0]; + algebraic[1] = rates[0]; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index b6ba332de..339060053 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -42,7 +42,7 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 1.0 + computed_constants[0] = 1.0 states[0] = 1.0 @@ -51,8 +51,8 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = variables[0] + rates[0] = computed_constants[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[1] = rates[0] + algebraic[1] = rates[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 3ad5d8762..cd735eda2 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -53,7 +53,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 1.0; + computedConstants[0] = 1.0; states[0] = 1.0; } @@ -63,10 +63,10 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = variables[0]; + rates[0] = computedConstants[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[1] = 2.0*states[0]; + algebraic[1] = 2.0*states[0]; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index b8d4bcc52..bca3f1f41 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -42,7 +42,7 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 1.0 + computed_constants[0] = 1.0 states[0] = 1.0 @@ -51,8 +51,8 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = variables[0] + rates[0] = computed_constants[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[1] = 2.0*states[0] + algebraic[1] = 2.0*states[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 18593d131..8836720f3 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -53,7 +53,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 1.0; + computedConstants[0] = 1.0; states[0] = 1.0; } @@ -63,10 +63,10 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = variables[0]; + rates[0] = computedConstants[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[1] = 2.0*states[0]; + algebraic[1] = 2.0*states[0]; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 6bbd5c64c..409f890e5 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -42,7 +42,7 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 1.0 + computed_constants[0] = 1.0 states[0] = 1.0 @@ -51,8 +51,8 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = variables[0] + rates[0] = computed_constants[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[1] = 2.0*states[0] + algebraic[1] = 2.0*states[0] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index f8f2240c0..8466d70b1 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -46,9 +46,9 @@ void objectiveFunction0(double *u, double *f, void *data) { double *variables = ((RootFindingInfo *) data)->variables; - variables[3] = u[0]; + algebraic[3] = u[0]; - f[0] = variables[3]+variables[0]-(variables[1]+variables[2]); + f[0] = algebraic[3]+computedConstants[0]-(computedConstants[1]+computedConstants[2]); } void findRoot0(double *variables) @@ -56,19 +56,19 @@ void findRoot0(double *variables) RootFindingInfo rfi = { variables }; double u[1]; - u[0] = variables[3]; + u[0] = algebraic[3]; nlaSolve(objectiveFunction0, u, 1, &rfi); - variables[3] = u[0]; + algebraic[3] = u[0]; } void initialiseVariables(double *constants) { - variables[3] = 1.0; - variables[0] = 3.0; - variables[1] = 5.0; - variables[2] = 7.0; + algebraic[3] = 1.0; + computedConstants[0] = 3.0; + computedConstants[1] = 5.0; + computedConstants[2] = 7.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index 3117d0d81..57c92c1e1 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -37,10 +37,10 @@ void deleteArray(double *array) void initialiseVariables(double *constants, ExternalVariable externalVariable) { - variables[0] = 3.0; - variables[1] = 5.0; - variables[2] = 7.0; - variables[3] = externalVariable(variables, 3); + computedConstants[0] = 3.0; + computedConstants[1] = 5.0; + computedConstants[2] = 7.0; + algebraic[3] = externalVariable(variables, 3); } void computeComputedConstants(double *constants, double *computedConstants) @@ -49,5 +49,5 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[3] = externalVariable(variables, 3); + algebraic[3] = externalVariable(variables, 3); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index a2b79b941..de574c904 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -32,10 +32,10 @@ def create_variables_array(): def initialise_variables(constants, external_variable): - variables[0] = 3.0 - variables[1] = 5.0 - variables[2] = 7.0 - variables[3] = external_variable(variables, 3) + computed_constants[0] = 3.0 + computed_constants[1] = 5.0 + computed_constants[2] = 7.0 + algebraic[3] = external_variable(variables, 3) def compute_computed_constants(constants, computed_constants): @@ -43,4 +43,4 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - variables[3] = external_variable(variables, 3) + algebraic[3] = external_variable(variables, 3) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index f85863b93..646d98b2a 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -36,26 +36,26 @@ def create_variables_array(): def objective_function_0(u, f, data): variables = data[0] - variables[3] = u[0] + algebraic[3] = u[0] - f[0] = variables[3]+variables[0]-(variables[1]+variables[2]) + f[0] = algebraic[3]+computed_constants[0]-(computed_constants[1]+computed_constants[2]) def find_root_0(variables): u = [nan]*1 - u[0] = variables[3] + u[0] = algebraic[3] u = nla_solve(objective_function_0, u, 1, [variables]) - variables[3] = u[0] + algebraic[3] = u[0] def initialise_variables(constants): - variables[3] = 1.0 - variables[0] = 3.0 - variables[1] = 5.0 - variables[2] = 7.0 + algebraic[3] = 1.0 + computed_constants[0] = 3.0 + computed_constants[1] = 5.0 + computed_constants[2] = 7.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index 535e4e8e6..eb6d409ad 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -45,13 +45,13 @@ void objectiveFunction0(double *u, double *f, void *data) { double *variables = ((RootFindingInfo *) data)->variables; - variables[0] = u[0]; - variables[1] = u[1]; - variables[2] = u[2]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; + algebraic[2] = u[2]; - f[0] = 2.0*variables[0]+variables[1]-2.0*variables[2]-(-1.0); - f[1] = 3.0*variables[0]-3.0*variables[1]-variables[2]-5.0; - f[2] = variables[0]-2.0*variables[1]+3.0*variables[2]-6.0; + f[0] = 2.0*algebraic[0]+algebraic[1]-2.0*algebraic[2]-(-1.0); + f[1] = 3.0*algebraic[0]-3.0*algebraic[1]-algebraic[2]-5.0; + f[2] = algebraic[0]-2.0*algebraic[1]+3.0*algebraic[2]-6.0; } void findRoot0(double *variables) @@ -59,22 +59,22 @@ void findRoot0(double *variables) RootFindingInfo rfi = { variables }; double u[3]; - u[0] = variables[0]; - u[1] = variables[1]; - u[2] = variables[2]; + u[0] = algebraic[0]; + u[1] = algebraic[1]; + u[2] = algebraic[2]; nlaSolve(objectiveFunction0, u, 3, &rfi); - variables[0] = u[0]; - variables[1] = u[1]; - variables[2] = u[2]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; + algebraic[2] = u[2]; } void initialiseVariables(double *constants) { - variables[0] = 1.0; - variables[1] = 1.0; - variables[2] = 1.0; + algebraic[0] = 1.0; + algebraic[1] = 1.0; + algebraic[2] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index cd3f4d26a..de50e042e 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -35,33 +35,33 @@ def create_variables_array(): def objective_function_0(u, f, data): variables = data[0] - variables[0] = u[0] - variables[1] = u[1] - variables[2] = u[2] + algebraic[0] = u[0] + algebraic[1] = u[1] + algebraic[2] = u[2] - f[0] = 2.0*variables[0]+variables[1]-2.0*variables[2]-(-1.0) - f[1] = 3.0*variables[0]-3.0*variables[1]-variables[2]-5.0 - f[2] = variables[0]-2.0*variables[1]+3.0*variables[2]-6.0 + f[0] = 2.0*algebraic[0]+algebraic[1]-2.0*algebraic[2]-(-1.0) + f[1] = 3.0*algebraic[0]-3.0*algebraic[1]-algebraic[2]-5.0 + f[2] = algebraic[0]-2.0*algebraic[1]+3.0*algebraic[2]-6.0 def find_root_0(variables): u = [nan]*3 - u[0] = variables[0] - u[1] = variables[1] - u[2] = variables[2] + u[0] = algebraic[0] + u[1] = algebraic[1] + u[2] = algebraic[2] u = nla_solve(objective_function_0, u, 3, [variables]) - variables[0] = u[0] - variables[1] = u[1] - variables[2] = u[2] + algebraic[0] = u[0] + algebraic[1] = u[1] + algebraic[2] = u[2] def initialise_variables(constants): - variables[0] = 1.0 - variables[1] = 1.0 - variables[2] = 1.0 + algebraic[0] = 1.0 + algebraic[1] = 1.0 + algebraic[2] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index 4f5a98709..db8bace3d 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -36,9 +36,9 @@ void deleteArray(double *array) void initialiseVariables(double *constants, ExternalVariable externalVariable) { - variables[0] = externalVariable(variables, 0); - variables[1] = externalVariable(variables, 1); - variables[2] = externalVariable(variables, 2); + algebraic[0] = externalVariable(variables, 0); + algebraic[1] = externalVariable(variables, 1); + algebraic[2] = externalVariable(variables, 2); } void computeComputedConstants(double *constants, double *computedConstants) @@ -47,7 +47,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[0] = externalVariable(variables, 0); - variables[1] = externalVariable(variables, 1); - variables[2] = externalVariable(variables, 2); + algebraic[0] = externalVariable(variables, 0); + algebraic[1] = externalVariable(variables, 1); + algebraic[2] = externalVariable(variables, 2); } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index 83aafcbbc..0e99da282 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -31,9 +31,9 @@ def create_variables_array(): def initialise_variables(constants, external_variable): - variables[0] = external_variable(variables, 0) - variables[1] = external_variable(variables, 1) - variables[2] = external_variable(variables, 2) + algebraic[0] = external_variable(variables, 0) + algebraic[1] = external_variable(variables, 1) + algebraic[2] = external_variable(variables, 2) def compute_computed_constants(constants, computed_constants): @@ -41,6 +41,6 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - variables[0] = external_variable(variables, 0) - variables[1] = external_variable(variables, 1) - variables[2] = external_variable(variables, 2) + algebraic[0] = external_variable(variables, 0) + algebraic[1] = external_variable(variables, 1) + algebraic[2] = external_variable(variables, 2) diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index 462c28f73..209f9dc7b 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -48,11 +48,11 @@ void objectiveFunction0(double *u, double *f, void *data) { double *variables = ((RootFindingInfo *) data)->variables; - variables[2] = u[0]; - variables[1] = u[1]; + algebraic[2] = u[0]; + algebraic[1] = u[1]; - f[0] = 3.0*variables[3]+2.0*variables[1]+variables[2]-57.0; - f[1] = variables[3]+3.0*variables[1]-variables[2]-19.0; + f[0] = 3.0*computedConstants[3]+2.0*algebraic[1]+algebraic[2]-57.0; + f[1] = computedConstants[3]+3.0*algebraic[1]-algebraic[2]-19.0; } void findRoot0(double *variables) @@ -60,30 +60,30 @@ void findRoot0(double *variables) RootFindingInfo rfi = { variables }; double u[2]; - u[0] = variables[2]; - u[1] = variables[1]; + u[0] = algebraic[2]; + u[1] = algebraic[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - variables[2] = u[0]; - variables[1] = u[1]; + algebraic[2] = u[0]; + algebraic[1] = u[1]; } void initialiseVariables(double *constants) { - variables[1] = 1.0; - variables[2] = 1.0; - variables[4] = 3.0; - variables[5] = 5.0; + algebraic[1] = 1.0; + algebraic[2] = 1.0; + constants[4] = 3.0; + constants[5] = 5.0; } void computeComputedConstants(double *constants, double *computedConstants) { - variables[3] = 3.0*variables[4]+variables[5]; + computedConstants[3] = 3.0*constants[4]+constants[5]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) { findRoot0(variables); - variables[0] = variables[1]+variables[2]; + algebraic[0] = algebraic[1]+algebraic[2]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 723234a88..2c1c63ab8 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -38,36 +38,36 @@ def create_variables_array(): def objective_function_0(u, f, data): variables = data[0] - variables[2] = u[0] - variables[1] = u[1] + algebraic[2] = u[0] + algebraic[1] = u[1] - f[0] = 3.0*variables[3]+2.0*variables[1]+variables[2]-57.0 - f[1] = variables[3]+3.0*variables[1]-variables[2]-19.0 + f[0] = 3.0*computed_constants[3]+2.0*algebraic[1]+algebraic[2]-57.0 + f[1] = computed_constants[3]+3.0*algebraic[1]-algebraic[2]-19.0 def find_root_0(variables): u = [nan]*2 - u[0] = variables[2] - u[1] = variables[1] + u[0] = algebraic[2] + u[1] = algebraic[1] u = nla_solve(objective_function_0, u, 2, [variables]) - variables[2] = u[0] - variables[1] = u[1] + algebraic[2] = u[0] + algebraic[1] = u[1] def initialise_variables(constants): - variables[1] = 1.0 - variables[2] = 1.0 - variables[4] = 3.0 - variables[5] = 5.0 + algebraic[1] = 1.0 + algebraic[2] = 1.0 + constants[4] = 3.0 + constants[5] = 5.0 def compute_computed_constants(constants, computed_constants): - variables[3] = 3.0*variables[4]+variables[5] + computed_constants[3] = 3.0*constants[4]+constants[5] def compute_variables(constants, computed_constants, algebraic): find_root_0(variables) - variables[0] = variables[1]+variables[2] + algebraic[0] = algebraic[1]+algebraic[2] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index e8af03001..2802b5299 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -48,11 +48,11 @@ void objectiveFunction0(double *u, double *f, void *data) { double *variables = ((RootFindingInfo *) data)->variables; - variables[3] = u[0]; - variables[4] = u[1]; + algebraic[3] = u[0]; + algebraic[4] = u[1]; - f[0] = 3.0*variables[0]+2.0*variables[4]+variables[3]-57.0; - f[1] = variables[0]+3.0*variables[4]-variables[3]-19.0; + f[0] = 3.0*computedConstants[0]+2.0*algebraic[4]+algebraic[3]-57.0; + f[1] = computedConstants[0]+3.0*algebraic[4]-algebraic[3]-19.0; } void findRoot0(double *variables) @@ -60,30 +60,30 @@ void findRoot0(double *variables) RootFindingInfo rfi = { variables }; double u[2]; - u[0] = variables[3]; - u[1] = variables[4]; + u[0] = algebraic[3]; + u[1] = algebraic[4]; nlaSolve(objectiveFunction0, u, 2, &rfi); - variables[3] = u[0]; - variables[4] = u[1]; + algebraic[3] = u[0]; + algebraic[4] = u[1]; } void initialiseVariables(double *constants) { - variables[1] = 3.0; - variables[2] = 5.0; - variables[3] = 1.0; - variables[4] = 1.0; + constants[1] = 3.0; + constants[2] = 5.0; + algebraic[3] = 1.0; + algebraic[4] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - variables[0] = 3.0*variables[1]+variables[2]; + computedConstants[0] = 3.0*constants[1]+constants[2]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) { findRoot0(variables); - variables[5] = variables[4]+variables[3]; + algebraic[5] = algebraic[4]+algebraic[3]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 20c8f3155..d6259b2b9 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -38,36 +38,36 @@ def create_variables_array(): def objective_function_0(u, f, data): variables = data[0] - variables[3] = u[0] - variables[4] = u[1] + algebraic[3] = u[0] + algebraic[4] = u[1] - f[0] = 3.0*variables[0]+2.0*variables[4]+variables[3]-57.0 - f[1] = variables[0]+3.0*variables[4]-variables[3]-19.0 + f[0] = 3.0*computed_constants[0]+2.0*algebraic[4]+algebraic[3]-57.0 + f[1] = computed_constants[0]+3.0*algebraic[4]-algebraic[3]-19.0 def find_root_0(variables): u = [nan]*2 - u[0] = variables[3] - u[1] = variables[4] + u[0] = algebraic[3] + u[1] = algebraic[4] u = nla_solve(objective_function_0, u, 2, [variables]) - variables[3] = u[0] - variables[4] = u[1] + algebraic[3] = u[0] + algebraic[4] = u[1] def initialise_variables(constants): - variables[1] = 3.0 - variables[2] = 5.0 - variables[3] = 1.0 - variables[4] = 1.0 + constants[1] = 3.0 + constants[2] = 5.0 + algebraic[3] = 1.0 + algebraic[4] = 1.0 def compute_computed_constants(constants, computed_constants): - variables[0] = 3.0*variables[1]+variables[2] + computed_constants[0] = 3.0*constants[1]+constants[2] def compute_variables(constants, computed_constants, algebraic): find_root_0(variables) - variables[5] = variables[4]+variables[3] + algebraic[5] = algebraic[4]+algebraic[3] diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index 5224ee214..16b90c388 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -35,12 +35,12 @@ void deleteArray(double *array) void initialiseVariables(double *constants) { - variables[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - variables[1] = variables[0]; + computedConstants[1] = computedConstants[0]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index c4bec2a5c..3edee3ead 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -29,11 +29,11 @@ def create_variables_array(): def initialise_variables(constants): - variables[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - variables[1] = variables[0] + computed_constants[1] = computed_constants[0] def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index 8087a0ebc..91884cff9 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -37,14 +37,14 @@ void deleteArray(double *array) void initialiseVariables(double *constants) { - variables[1] = 0.01; - variables[2] = 0.0011; + constants[1] = 0.01; + constants[2] = 0.0011; } void computeComputedConstants(double *constants, double *computedConstants) { - variables[0] = 1000.0*3.14*variables[2]*variables[2]*variables[1]; - variables[3] = 0.02*variables[0]; + computedConstants[0] = 1000.0*3.14*constants[2]*constants[2]*constants[1]; + computedConstants[3] = 0.02*computedConstants[0]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index c9c0f76f8..ed88fb63d 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -37,8 +37,8 @@ void deleteArray(double *array) void initialiseVariables(double *constants, ExternalVariable externalVariable) { - variables[1] = externalVariable(variables, 1); - variables[2] = externalVariable(variables, 2); + algebraic[1] = externalVariable(variables, 1); + algebraic[2] = externalVariable(variables, 2); } void computeComputedConstants(double *constants, double *computedConstants) @@ -47,8 +47,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[1] = externalVariable(variables, 1); - variables[2] = externalVariable(variables, 2); - variables[0] = 1000.0*3.14*variables[2]*variables[2]*variables[1]; - variables[3] = 0.02*variables[0]; + algebraic[1] = externalVariable(variables, 1); + algebraic[2] = externalVariable(variables, 2); + algebraic[0] = 1000.0*3.14*algebraic[2]*algebraic[2]*algebraic[1]; + algebraic[3] = 0.02*algebraic[0]; } diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 2e565edd4..752da86d5 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -32,8 +32,8 @@ def create_variables_array(): def initialise_variables(constants, external_variable): - variables[1] = external_variable(variables, 1) - variables[2] = external_variable(variables, 2) + algebraic[1] = external_variable(variables, 1) + algebraic[2] = external_variable(variables, 2) def compute_computed_constants(constants, computed_constants): @@ -41,7 +41,7 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - variables[1] = external_variable(variables, 1) - variables[2] = external_variable(variables, 2) - variables[0] = 1000.0*3.14*variables[2]*variables[2]*variables[1] - variables[3] = 0.02*variables[0] + algebraic[1] = external_variable(variables, 1) + algebraic[2] = external_variable(variables, 2) + algebraic[0] = 1000.0*3.14*algebraic[2]*algebraic[2]*algebraic[1] + algebraic[3] = 0.02*algebraic[0] diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index dd282fbf3..bcbef6f85 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -31,13 +31,13 @@ def create_variables_array(): def initialise_variables(constants): - variables[1] = 0.01 - variables[2] = 0.0011 + constants[1] = 0.01 + constants[2] = 0.0011 def compute_computed_constants(constants, computed_constants): - variables[0] = 1000.0*3.14*variables[2]*variables[2]*variables[1] - variables[3] = 0.02*variables[0] + computed_constants[0] = 1000.0*3.14*constants[2]*constants[2]*constants[1] + computed_constants[3] = 0.02*computed_constants[0] def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index af77c8adb..3f59baaf8 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -70,6 +70,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0); - variables[1] = 2.0*states[1]; + algebraic[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0); + algebraic[1] = 2.0*states[1]; } diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 48ead204d..42799d811 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -57,5 +57,5 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0) - variables[1] = 2.0*states[1] + algebraic[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0) + algebraic[1] = 2.0*states[1] diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index e46136ff8..ea8cac8cf 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -37,19 +37,19 @@ def create_variables_array(): def initialise_variables(constants): - variables[1] = 1.1 - variables[2] = 21262500.0 - variables[3] = 150.0 - variables[4] = 3402000.0 - variables[5] = 2.0 - variables[6] = 2902500.0 - variables[7] = 810000.0 - variables[8] = 247140.0 - variables[9] = 2902500.0 + constants[1] = 1.1 + constants[2] = 21262500.0 + constants[3] = 150.0 + constants[4] = 3402000.0 + constants[5] = 2.0 + constants[6] = 2902500.0 + constants[7] = 810000.0 + constants[8] = 247140.0 + constants[9] = 2902500.0 def compute_computed_constants(constants, computed_constants): - variables[0] = variables[1]*(variables[2]*variables[3]-variables[4]*variables[5])/(variables[6]*variables[5]+variables[9]*variables[3]+variables[8]*variables[5]*variables[3]+variables[7]) + computed_constants[0] = constants[1]*(constants[2]*constants[3]-constants[4]*constants[5])/(constants[6]*constants[5]+constants[9]*constants[3]+constants[8]*constants[5]*constants[3]+constants[7]) def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index fd33a5b30..3bb1425bc 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -52,8 +52,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 123.0; - states[0] = variables[0]; + constants[0] = 123.0; + states[0] = constants[0]; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 246d135ba..2ae891fe3 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -41,8 +41,8 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 123.0 - states[0] = variables[0] + constants[0] = 123.0 + states[0] = constants[0] def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 5ec839f54..79847cd59 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -36,13 +36,13 @@ void deleteArray(double *array) void initialiseVariables(double *constants) { - variables[0] = 123.0; + constants[0] = 123.0; } void computeComputedConstants(double *constants, double *computedConstants) { - variables[1] = variables[0]+variables[0]; - variables[2] = 0.001*variables[0]+0.001*variables[0]; + computedConstants[1] = constants[0]+constants[0]; + computedConstants[2] = 0.001*constants[0]+0.001*constants[0]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index 83f5af0c9..8d1f0b000 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -30,12 +30,12 @@ def create_variables_array(): def initialise_variables(constants): - variables[0] = 123.0 + constants[0] = 123.0 def compute_computed_constants(constants, computed_constants): - variables[1] = variables[0]+variables[0] - variables[2] = 0.001*variables[0]+0.001*variables[0] + computed_constants[1] = constants[0]+constants[0] + computed_constants[2] = 0.001*constants[0]+0.001*constants[0] def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 56547ca65..603a1eab3 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -67,6 +67,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[0] = 1000.0*rates[0]+1000.0*rates[0]; - variables[1] = 1000.0*0.001*rates[0]+1000.0*0.001*rates[0]; + algebraic[0] = 1000.0*rates[0]+1000.0*rates[0]; + algebraic[1] = 1000.0*0.001*rates[0]+1000.0*0.001*rates[0]; } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 97589bc34..f74588e12 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -54,5 +54,5 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[0] = 1000.0*rates[0]+1000.0*rates[0] - variables[1] = 1000.0*0.001*rates[0]+1000.0*0.001*rates[0] + algebraic[0] = 1000.0*rates[0]+1000.0*rates[0] + algebraic[1] = 1000.0*0.001*rates[0]+1000.0*0.001*rates[0] diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index fc1ab5e93..34c1bca1f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -67,6 +67,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[0] = states[0]+states[0]; - variables[1] = 0.001*states[0]+0.001*states[0]; + algebraic[0] = states[0]+states[0]; + algebraic[1] = 0.001*states[0]+0.001*states[0]; } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index 1c964deb8..ec43146e3 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -54,5 +54,5 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[0] = states[0]+states[0] - variables[1] = 0.001*states[0]+0.001*states[0] + algebraic[0] = states[0]+states[0] + algebraic[1] = 0.001*states[0]+0.001*states[0] diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index bafc5259f..ba05a38f2 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -54,10 +54,10 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 123.0; - variables[1] = 789.0; - states[0] = variables[0]; - states[1] = 0.001*variables[1]; + constants[0] = 123.0; + constants[1] = 789.0; + states[0] = constants[0]; + states[1] = 0.001*constants[1]; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 029b44f7a..ce584f1b0 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -43,10 +43,10 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 123.0 - variables[1] = 789.0 - states[0] = variables[0] - states[1] = 0.001*variables[1] + constants[0] = 123.0 + constants[1] = 789.0 + states[0] = constants[0] + states[1] = 0.001*constants[1] def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index c349b48ca..aff41afb7 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -77,9 +77,9 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[0] = u[0]; + algebraic[0] = u[0]; - f[0] = variables[1]-(variables[0]+variables[2]); + f[0] = constants[1]-(algebraic[0]+algebraic[2]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -87,11 +87,11 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[0]; + u[0] = algebraic[0]; nlaSolve(objectiveFunction0, u, 1, &rfi); - variables[0] = u[0]; + algebraic[0] = u[0]; } void objectiveFunction1(double *u, double *f, void *data) @@ -101,9 +101,9 @@ void objectiveFunction1(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[6] = u[0]; + algebraic[6] = u[0]; - f[0] = variables[4]-(variables[5]+variables[6]); + f[0] = algebraic[4]-(algebraic[5]+algebraic[6]); } void findRoot1(double voi, double *states, double *rates, double *variables) @@ -111,22 +111,22 @@ void findRoot1(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[6]; + u[0] = algebraic[6]; nlaSolve(objectiveFunction1, u, 1, &rfi); - variables[6] = u[0]; + algebraic[6] = u[0]; } void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 0.0; - variables[1] = 1.0; - variables[3] = 1.0; - variables[6] = 0.0; - variables[7] = 20.0; - variables[8] = 2.0; - variables[9] = 10.0; + algebraic[0] = 0.0; + constants[1] = 1.0; + constants[3] = 1.0; + algebraic[6] = 0.0; + constants[7] = 20.0; + constants[8] = 2.0; + constants[9] = 10.0; states[0] = 1.0; states[1] = 0.0; } @@ -137,20 +137,20 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[2] = states[1]+variables[3]; + algebraic[2] = states[1]+constants[3]; findRoot0(voi, states, rates, variables); - rates[0] = variables[0]; - variables[4] = states[0]/variables[7]; - variables[5] = variables[8]*variables[2]; + rates[0] = algebraic[0]; + algebraic[4] = states[0]/constants[7]; + algebraic[5] = constants[8]*algebraic[2]; findRoot1(voi, states, rates, variables); - rates[1] = variables[6]/variables[9]; + rates[1] = algebraic[6]/constants[9]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[2] = states[1]+variables[3]; + algebraic[2] = states[1]+constants[3]; findRoot0(voi, states, rates, variables); - variables[4] = states[0]/variables[7]; - variables[5] = variables[8]*variables[2]; + algebraic[4] = states[0]/constants[7]; + algebraic[5] = constants[8]*algebraic[2]; findRoot1(voi, states, rates, variables); } diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 793f148fa..764fb8703 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -59,19 +59,19 @@ def objective_function_0(u, f, data): rates = data[2] variables = data[3] - variables[0] = u[0] + algebraic[0] = u[0] - f[0] = variables[1]-(variables[0]+variables[2]) + f[0] = constants[1]-(algebraic[0]+algebraic[2]) def find_root_0(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[0] + u[0] = algebraic[0] u = nla_solve(objective_function_0, u, 1, [voi, states, rates, variables]) - variables[0] = u[0] + algebraic[0] = u[0] def objective_function_1(u, f, data): @@ -80,29 +80,29 @@ def objective_function_1(u, f, data): rates = data[2] variables = data[3] - variables[6] = u[0] + algebraic[6] = u[0] - f[0] = variables[4]-(variables[5]+variables[6]) + f[0] = algebraic[4]-(algebraic[5]+algebraic[6]) def find_root_1(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[6] + u[0] = algebraic[6] u = nla_solve(objective_function_1, u, 1, [voi, states, rates, variables]) - variables[6] = u[0] + algebraic[6] = u[0] def initialise_variables(states, rates, constants): - variables[0] = 0.0 - variables[1] = 1.0 - variables[3] = 1.0 - variables[6] = 0.0 - variables[7] = 20.0 - variables[8] = 2.0 - variables[9] = 10.0 + algebraic[0] = 0.0 + constants[1] = 1.0 + constants[3] = 1.0 + algebraic[6] = 0.0 + constants[7] = 20.0 + constants[8] = 2.0 + constants[9] = 10.0 states[0] = 1.0 states[1] = 0.0 @@ -112,18 +112,18 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - variables[2] = states[1]+variables[3] + algebraic[2] = states[1]+constants[3] find_root_0(voi, states, rates, variables) - rates[0] = variables[0] - variables[4] = states[0]/variables[7] - variables[5] = variables[8]*variables[2] + rates[0] = algebraic[0] + algebraic[4] = states[0]/constants[7] + algebraic[5] = constants[8]*algebraic[2] find_root_1(voi, states, rates, variables) - rates[1] = variables[6]/variables[9] + rates[1] = algebraic[6]/constants[9] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[2] = states[1]+variables[3] + algebraic[2] = states[1]+constants[3] find_root_0(voi, states, rates, variables) - variables[4] = states[0]/variables[7] - variables[5] = variables[8]*variables[2] + algebraic[4] = states[0]/constants[7] + algebraic[5] = constants[8]*algebraic[2] find_root_1(voi, states, rates, variables) diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index e85abef76..7bbb98144 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -67,6 +67,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[1] = 2.0*voi; - variables[0] = 3.0*variables[1]; + algebraic[1] = 2.0*voi; + algebraic[0] = 3.0*algebraic[1]; } diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index a5a26864c..5ed89e910 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -54,5 +54,5 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[1] = 2.0*voi - variables[0] = 3.0*variables[1] + algebraic[1] = 2.0*voi + algebraic[0] = 3.0*algebraic[1] diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index ee620de9a..ccb8d7ddf 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -300,97 +300,97 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 0.0; - variables[1] = 0.0; - variables[4] = 140.0; - variables[7] = 5.4; - variables[8] = 140.0; - variables[10] = 1.8; - variables[11] = 1.0; - variables[17] = 96485.3415; - variables[22] = 14.0; - variables[23] = 1.4; - variables[24] = 0.08105; - variables[25] = 0.0; - variables[30] = 3.343; - variables[39] = 26.44; - variables[40] = 0.0207; - variables[41] = 0.1369; - variables[43] = 395.3; - variables[44] = 2.289; - variables[45] = 0.4315; - variables[46] = 26.44; - variables[47] = 4.663; - variables[48] = 3.663; - variables[49] = 0.0; - variables[51] = 1628.0; - variables[52] = 561.4; - variables[54] = 148041085.1; - variables[57] = 15.0; - variables[58] = 1.0; - variables[59] = 0.45; - variables[60] = 2.5; - variables[62] = 10000.0; - variables[64] = 500.0; - variables[65] = 5.0; - variables[66] = 660.0; - variables[70] = 5.0; - variables[72] = 5.469e-5; - variables[74] = 0.000286113; - variables[75] = 5.0e-5; - variables[77] = 0.04; - variables[79] = 88800.0; - variables[80] = 446.0; - variables[82] = 227700.0; - variables[83] = 7.51; - variables[85] = 2277.0; - variables[86] = 2.5; - variables[87] = 751.0; - variables[89] = 1.642e6; - variables[90] = 542.0; - variables[93] = 175.4; - variables[94] = 445.0; - variables[95] = 0.031; - variables[96] = 0.062; - variables[97] = 0.045; - variables[98] = 10.0; - variables[104] = 67.0; - variables[105] = 3.9; - variables[106] = 0.02; - variables[107] = 0.0012; - variables[108] = 0.46; - variables[109] = 0.0116; - variables[118] = 5.7e-5; - variables[119] = 8314.472; - variables[120] = 310.0; - variables[122] = 0.0; - variables[123] = -35.0; - variables[124] = 0.5; - variables[125] = 0.5; - variables[126] = -45.0; - variables[128] = 0.00427; - variables[129] = 45.0; - variables[131] = 0.5927; - variables[135] = 0.0; - variables[141] = 0.0; - variables[144] = 0.0223; - variables[146] = 0.0; - variables[150] = 1.0e-5; - variables[157] = 0.1539e-3; - variables[163] = 0.4578; - variables[169] = -16.4508; - variables[170] = 4.3371; - variables[177] = 0.0; - variables[178] = 0.0; - variables[181] = 0.000338; - variables[183] = 0.0075; - variables[184] = 0.04132; - variables[189] = 0.0; - variables[190] = 3.5e-3; - variables[195] = 0.00424; - variables[204] = 0.00065; - variables[211] = 1.0; - variables[212] = 0.00345; + constants[0] = 0.0; + constants[1] = 0.0; + constants[4] = 140.0; + constants[7] = 5.4; + constants[8] = 140.0; + constants[10] = 1.8; + constants[11] = 1.0; + constants[17] = 96485.3415; + constants[22] = 14.0; + constants[23] = 1.4; + constants[24] = 0.08105; + constants[25] = 0.0; + constants[30] = 3.343; + constants[39] = 26.44; + constants[40] = 0.0207; + constants[41] = 0.1369; + constants[43] = 395.3; + constants[44] = 2.289; + constants[45] = 0.4315; + constants[46] = 26.44; + constants[47] = 4.663; + constants[48] = 3.663; + constants[49] = 0.0; + constants[51] = 1628.0; + constants[52] = 561.4; + constants[54] = 148041085.1; + constants[57] = 15.0; + constants[58] = 1.0; + constants[59] = 0.45; + constants[60] = 2.5; + constants[62] = 10000.0; + constants[64] = 500.0; + constants[65] = 5.0; + constants[66] = 660.0; + constants[70] = 5.0; + constants[72] = 5.469e-5; + constants[74] = 0.000286113; + constants[75] = 5.0e-5; + constants[77] = 0.04; + constants[79] = 88800.0; + constants[80] = 446.0; + constants[82] = 227700.0; + constants[83] = 7.51; + constants[85] = 2277.0; + constants[86] = 2.5; + constants[87] = 751.0; + constants[89] = 1.642e6; + constants[90] = 542.0; + constants[93] = 175.4; + constants[94] = 445.0; + constants[95] = 0.031; + constants[96] = 0.062; + constants[97] = 0.045; + constants[98] = 10.0; + constants[104] = 67.0; + constants[105] = 3.9; + constants[106] = 0.02; + constants[107] = 0.0012; + constants[108] = 0.46; + constants[109] = 0.0116; + constants[118] = 5.7e-5; + constants[119] = 8314.472; + constants[120] = 310.0; + constants[122] = 0.0; + constants[123] = -35.0; + constants[124] = 0.5; + constants[125] = 0.5; + constants[126] = -45.0; + constants[128] = 0.00427; + constants[129] = 45.0; + constants[131] = 0.5927; + constants[135] = 0.0; + constants[141] = 0.0; + constants[144] = 0.0223; + constants[146] = 0.0; + constants[150] = 1.0e-5; + constants[157] = 0.1539e-3; + constants[163] = 0.4578; + constants[169] = -16.4508; + constants[170] = 4.3371; + constants[177] = 0.0; + constants[178] = 0.0; + constants[181] = 0.000338; + constants[183] = 0.0075; + constants[184] = 0.04132; + constants[189] = 0.0; + constants[190] = 3.5e-3; + constants[195] = 0.00424; + constants[204] = 0.00065; + constants[211] = 1.0; + constants[212] = 0.00345; states[0] = 6.226104e-5; states[1] = 5.0; states[2] = 0.409551; @@ -428,266 +428,266 @@ void initialiseVariables(double *states, double *rates, double *constants) void computeComputedConstants(double *constants, double *computedConstants) { - variables[3] = variables[119]*variables[120]/variables[17]; - variables[6] = variables[3]*log(variables[7]/variables[8]); - variables[20] = (variables[1] > 0.0)?1.2:1.0; - variables[35] = variables[4]/(variables[47]+variables[4]); - variables[68] = (variables[1] > 0.0)?-0.25:(variables[0] > 0.0)?0.7*variables[0]/(0.00009+variables[0]):0.0; - variables[69] = variables[70]*(1.0-variables[68]); - variables[103] = 0.000000001*3.14159265358979*pow(variables[105], 2.0)*variables[104]; - variables[19] = 0.000000001*2.0*3.14159265358979*variables[106]*(variables[105]-variables[106]/2.0)*variables[104]; - variables[100] = variables[107]*variables[103]; - variables[18] = variables[108]*variables[103]-variables[19]; - variables[99] = variables[109]*variables[103]; - variables[127] = variables[128]/(variables[7]/(variables[7]+variables[129])); - variables[130] = variables[127]/(variables[131]+1.0); - variables[132] = variables[131]*variables[130]; - variables[133] = variables[132]*variables[7]/(variables[7]+variables[129]); - variables[134] = variables[130]*variables[7]/(variables[7]+variables[129]); - variables[137] = (variables[0] > 0.0)?-1.0-9.898*pow(1.0*variables[0], 0.618)/(pow(1.0*variables[0], 0.618)+0.00122423):0.0; - variables[138] = (variables[1] > 0.0)?7.5:0.0; - variables[162] = (variables[1] > 0.0)?1.23:1.0; - variables[165] = 0.31*variables[0]/(variables[0]+0.00009); - variables[166] = (variables[1] > 0.0)?-8.0:0.0; - variables[167] = (variables[1] > 0.0)?-27.0:0.0; - variables[203] = (variables[1] > 0.0)?1.2*variables[204]:variables[204]; - variables[206] = (variables[1] > 0.0)?-14.0:0.0; - variables[213] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*variables[0], 1.6951))+0.025641; + computedConstants[3] = constants[119]*constants[120]/constants[17]; + computedConstants[6] = computedConstants[3]*log(constants[7]/constants[8]); + computedConstants[20] = (constants[1] > 0.0)?1.2:1.0; + computedConstants[35] = constants[4]/(constants[47]+constants[4]); + computedConstants[68] = (constants[1] > 0.0)?-0.25:(constants[0] > 0.0)?0.7*constants[0]/(0.00009+constants[0]):0.0; + computedConstants[69] = constants[70]*(1.0-computedConstants[68]); + computedConstants[103] = 0.000000001*3.14159265358979*pow(constants[105], 2.0)*constants[104]; + computedConstants[19] = 0.000000001*2.0*3.14159265358979*constants[106]*(constants[105]-constants[106]/2.0)*constants[104]; + computedConstants[100] = constants[107]*computedConstants[103]; + computedConstants[18] = constants[108]*computedConstants[103]-computedConstants[19]; + computedConstants[99] = constants[109]*computedConstants[103]; + computedConstants[127] = constants[128]/(constants[7]/(constants[7]+constants[129])); + computedConstants[130] = computedConstants[127]/(constants[131]+1.0); + computedConstants[132] = constants[131]*computedConstants[130]; + computedConstants[133] = computedConstants[132]*constants[7]/(constants[7]+constants[129]); + computedConstants[134] = computedConstants[130]*constants[7]/(constants[7]+constants[129]); + computedConstants[137] = (constants[0] > 0.0)?-1.0-9.898*pow(1.0*constants[0], 0.618)/(pow(1.0*constants[0], 0.618)+0.00122423):0.0; + computedConstants[138] = (constants[1] > 0.0)?7.5:0.0; + computedConstants[162] = (constants[1] > 0.0)?1.23:1.0; + computedConstants[165] = 0.31*constants[0]/(constants[0]+0.00009); + computedConstants[166] = (constants[1] > 0.0)?-8.0:0.0; + computedConstants[167] = (constants[1] > 0.0)?-27.0:0.0; + computedConstants[203] = (constants[1] > 0.0)?1.2*constants[204]:constants[204]; + computedConstants[206] = (constants[1] > 0.0)?-14.0:0.0; + computedConstants[213] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*constants[0], 1.6951))+0.025641; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[5] = states[1]; - variables[142] = variables[3]*log((variables[4]+0.12*variables[7])/(variables[5]+0.12*variables[8])); - variables[121] = ((voi > variables[124]) && (voi < variables[124]+variables[125]))?variables[123]:variables[126]; - variables[21] = (variables[122] >= 1.0)?variables[121]:states[15]; - variables[143] = variables[144]*pow(states[18], 3.0)*states[17]*(variables[21]-variables[142]); - variables[145] = variables[146]*pow(states[18], 3.0)*(variables[21]-variables[142]); - variables[12] = variables[143]+variables[145]; - variables[15] = 0.0000185*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)/variables[3])))*(variables[5]-variables[4]*exp(-1.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21]; - variables[2] = variables[3]*log(variables[4]/variables[5]); - variables[16] = states[16]*variables[133]*(variables[21]-variables[2])*(1.0-variables[135]); - variables[14] = variables[20]*variables[24]*pow(1.0+pow(variables[23]/variables[7], 1.2), -1.0)*pow(1.0+pow(variables[22]/variables[5], 1.3), -1.0)*pow(1.0+exp(-(variables[21]-variables[2]+110.0)/20.0), -1.0); - variables[50] = 1.0+variables[10]/variables[48]*(1.0+exp(variables[49]*variables[21]/variables[3]))+variables[4]/variables[51]*(1.0+variables[4]/variables[52]*(1.0+variables[4]/variables[47])); - variables[27] = variables[10]/variables[48]*exp(variables[49]*variables[21]/variables[3])/variables[50]; - variables[42] = 1.0+states[0]/variables[40]*(1.0+exp(-variables[41]*variables[21]/variables[3])+variables[5]/variables[46])+variables[5]/variables[43]*(1.0+variables[5]/variables[44]*(1.0+variables[5]/variables[39])); - variables[29] = states[0]/variables[40]*exp(-variables[41]*variables[21]/variables[3])/variables[42]; - variables[36] = variables[5]/(variables[39]+variables[5]); - variables[37] = exp(variables[45]*variables[21]/(2.0*variables[3])); - variables[33] = exp(-variables[45]*variables[21]/(2.0*variables[3])); - variables[38] = variables[5]/variables[43]*variables[5]/variables[44]*(1.0+variables[5]/variables[39])*exp(variables[45]*variables[21]/(2.0*variables[3]))/variables[42]; - variables[26] = variables[37]*variables[36]*(variables[38]+variables[29])+variables[33]*variables[29]*(variables[35]+variables[37]); - variables[34] = variables[4]/variables[51]*variables[4]/variables[52]*(1.0+variables[4]/variables[47])*exp(-variables[45]*variables[21]/(2.0*variables[3]))/variables[50]; - variables[28] = variables[33]*variables[35]*(variables[34]+variables[27])+variables[27]*variables[37]*(variables[36]+variables[33]); - variables[31] = variables[34]*variables[35]*(variables[38]+variables[29])+variables[38]*variables[27]*(variables[35]+variables[37]); - variables[32] = variables[38]*variables[36]*(variables[34]+variables[27])+variables[29]*variables[34]*(variables[36]+variables[33]); - variables[13] = (1.0-variables[25])*variables[30]*(variables[26]*variables[27]-variables[28]*variables[29])/(variables[28]+variables[26]+variables[32]+variables[31]); - rates[1] = (1.0-variables[11])*-1.0*(variables[12]+variables[16]+variables[15]+3.0*variables[14]+3.0*variables[13])/(1.0*(variables[18]+variables[19])*variables[17]); - variables[56] = variables[57]-(variables[57]-variables[58])/(1.0+pow(variables[59]/states[2], variables[60])); - variables[63] = variables[64]*variables[56]; - variables[61] = variables[62]/variables[56]; - rates[4] = variables[65]*states[5]-variables[63]*states[0]*states[4]-(variables[61]*pow(states[0], 2.0)*states[4]-variables[66]*states[3]); - rates[3] = variables[61]*pow(states[0], 2.0)*states[4]-variables[66]*states[3]-(variables[63]*states[0]*states[3]-variables[65]*states[6]); - rates[6] = variables[63]*states[0]*states[3]-variables[65]*states[6]-(variables[66]*states[6]-variables[61]*pow(states[0], 2.0)*states[5]); - rates[5] = variables[66]*states[6]-variables[61]*pow(states[0], 2.0)*states[5]-(variables[65]*states[5]-variables[63]*states[0]*states[4]); - variables[78] = variables[79]*states[7]*(1.0-states[9])-variables[80]*states[9]; - rates[9] = variables[78]; - variables[81] = variables[82]*states[7]*(1.0-(states[10]+states[11]))-variables[83]*states[10]; - rates[10] = variables[81]; - variables[84] = variables[85]*variables[86]*(1.0-(states[10]+states[11]))-variables[87]*states[11]; - rates[11] = variables[84]; - variables[88] = variables[89]*states[7]*(1.0-states[12])-variables[90]*states[12]; - rates[12] = variables[88]; - variables[91] = variables[89]*states[0]*(1.0-states[13])-variables[90]*states[13]; - rates[13] = variables[91]; - variables[92] = variables[93]*states[2]*(1.0-states[14])-variables[94]*states[14]; - rates[14] = variables[92]; - variables[71] = (states[0]-states[7])/variables[72]; - variables[73] = variables[69]/(1.0+exp((-states[7]+variables[74])/variables[75])); - rates[7] = 1.0*(variables[71]*variables[19]-variables[73]*variables[99])/variables[18]-(variables[97]*variables[88]+variables[95]*variables[78]+variables[96]*variables[81]); - variables[53] = variables[54]*states[3]*(states[2]-states[0]); - variables[101] = 2.0*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)*2.0/variables[3])))*(states[0]-variables[10]*exp(-2.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21]; - variables[102] = 2.0*variables[184]*variables[21]/(variables[3]*(1.0-exp(-1.0*variables[21]*2.0/variables[3])))*(states[0]-variables[10]*exp(-2.0*variables[21]/variables[3]))*states[25]*states[24]; - rates[0] = variables[53]*variables[100]/variables[19]-((variables[101]+variables[102]-2.0*variables[13])/(2.0*variables[17]*variables[19])+variables[71]+variables[97]*variables[91]); - variables[76] = (states[8]-states[2])/variables[77]; - rates[8] = variables[73]-variables[76]*variables[100]/variables[99]; - rates[2] = variables[76]-(variables[53]+variables[98]*variables[92]); - variables[136] = states[16]*variables[134]*(variables[21]-variables[6])*(1.0-variables[135]); - variables[111] = variables[16]+variables[136]; - variables[112] = variables[157]*states[20]*states[19]*(variables[21]-variables[6]); - variables[113] = (variables[0] > 0.0)?variables[211]*variables[212]*(variables[21]-variables[6])*(1.0+exp((variables[21]+20.0)/20.0))*states[32]:0.0; - variables[164] = 0.000365*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)/variables[3])))*(variables[8]-variables[7]*exp(-1.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21]; - variables[114] = (variables[101]+variables[164]+variables[15])*(1.0-variables[165])*1.0*variables[162]; - variables[115] = variables[190]*(variables[21]-variables[6])*states[27]*states[26]; - variables[205] = variables[3]*log((variables[7]+0.12*variables[4])/(variables[8]+0.12*variables[5])); - variables[116] = variables[203]*(variables[21]-variables[205])*pow(states[31], 2.0); - variables[117] = variables[195]*(variables[21]-variables[6])*(0.9*states[29]+0.1*states[30])*states[28]; - variables[110] = variables[111]+variables[117]+variables[116]+variables[115]+variables[14]+variables[13]+variables[12]+variables[114]+variables[102]+variables[113]+variables[112]; - rates[15] = -variables[110]/variables[118]; - variables[140] = (variables[21] < -(80.0-variables[137]-variables[138]-variables[141]))?0.01329+0.99921/(1.0+exp((variables[21]+97.134-variables[137]-variables[138]-variables[141])/8.1752)):0.0002501*exp(-(variables[21]-variables[137]-variables[138]-variables[141])/12.861); - variables[139] = 1.0/(0.36*(variables[21]+148.8-variables[137]-variables[138])/(exp(0.066*(variables[21]+148.8-variables[137]-variables[138]))-1.0)+0.1*(variables[21]+87.3-variables[137]-variables[138])/(1.0-exp(-0.2*(variables[21]+87.3-variables[137]-variables[138]))))-0.054; - rates[16] = (variables[140]-states[16])/variables[139]; - variables[147] = 1.0/(1.0+exp(-(variables[21]+42.0504)/8.3106)); - variables[148] = variables[21]+41.0; - variables[149] = (fabs(variables[148]) < variables[150])?2000.0:200.0*variables[148]/(1.0-exp(-0.1*variables[148])); - variables[151] = 8000.0*exp(-0.056*(variables[21]+66.0)); - variables[152] = 1.0/(variables[149]+variables[151]); - rates[18] = (variables[147]-states[18])/variables[152]; - variables[153] = 1.0/(1.0+exp((variables[21]+69.804)/4.4565)); - variables[154] = 20.0*exp(-0.125*(variables[21]+75.0)); - variables[155] = 2000.0/(320.0*exp(-0.1*(variables[21]+75.0))+1.0); - variables[156] = 1.0/(variables[154]+variables[155]); - rates[17] = (variables[153]-states[17])/variables[156]; - variables[158] = 1.0/(1.0+exp((variables[21]+6.0)/-8.6)); - variables[159] = 0.009/(1.0+exp((variables[21]+5.0)/12.0))+0.0005; - rates[20] = (variables[158]-states[20])/variables[159]; - variables[160] = 1.0/(1.0+exp((variables[21]+7.5)/10.0)); - variables[161] = 0.59/(1.0+exp((variables[21]+60.0)/10.0))+3.05; - rates[19] = (variables[160]-states[19])/variables[161]; - variables[168] = 1.0/(1.0+exp(-(variables[21]-variables[169]-variables[166])/(variables[170]*(1.0+variables[167]/100.0)))); - variables[174] = (variables[21] == -41.8)?-41.80001:(variables[21] == 0.0)?0.0:(variables[21] == -6.8)?-6.80001:variables[21]; - variables[172] = -0.02839*(variables[174]+41.8)/(exp(-(variables[174]+41.8)/2.5)-1.0)-0.0849*(variables[174]+6.8)/(exp(-(variables[174]+6.8)/4.8)-1.0); - variables[175] = (variables[21] == -1.8)?-1.80001:variables[21]; - variables[173] = 0.01143*(variables[175]+1.8)/(exp((variables[175]+1.8)/2.5)-1.0); - variables[171] = 0.001/(variables[172]+variables[173]); - rates[23] = (variables[168]-states[23])/variables[171]; - variables[176] = 1.0/(1.0+exp((variables[21]+37.4+variables[177])/(5.3+variables[178]))); - variables[179] = 0.001*(44.3+230.0*exp(-pow((variables[21]+36.0)/10.0, 2.0))); - rates[22] = (variables[176]-states[22])/variables[179]; - variables[180] = variables[181]/(variables[181]+states[0]); - variables[182] = 0.001*variables[180]/variables[183]; - rates[21] = (variables[180]-states[21])/variables[182]; - variables[185] = 1.0/(1.0+exp(-(variables[21]+38.3)/5.5)); - variables[186] = 0.001/(1.068*exp((variables[21]+38.3)/30.0)+1.068*exp(-(variables[21]+38.3)/30.0)); - rates[25] = (variables[185]-states[25])/variables[186]; - variables[187] = 1.0/(1.0+exp((variables[21]+58.7)/3.8)); - variables[188] = 1.0/(16.67*exp(-(variables[21]+75.0)/83.3)+16.67*exp((variables[21]+75.0)/15.38))+variables[189]; - rates[24] = (variables[187]-states[24])/variables[188]; - variables[191] = 1.0/(1.0+exp((variables[21]+49.0)/13.0)); - variables[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(variables[21]+44.0))+0.065*exp(0.1*(variables[21]+45.93)))+10.1); - rates[27] = (variables[191]-states[27])/variables[192]; - variables[193] = 1.0/(1.0+exp(-(variables[21]-19.3)/15.0)); - variables[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(variables[21]+30.61))+0.369*exp(-0.12*(variables[21]+23.84)))+2.98); - rates[26] = (variables[193]-states[26])/variables[194]; - variables[198] = 1.0/(1.0+exp(-(variables[21]+10.0144)/7.6607)); - variables[199] = 0.84655354/(4.2*exp(variables[21]/17.0)+0.15*exp(-variables[21]/21.6)); - rates[30] = (variables[198]-states[30])/variables[199]; - variables[200] = 1.0/(30.0*exp(variables[21]/10.0)+exp(-variables[21]/12.0)); - rates[29] = (variables[198]-states[29])/variables[200]; - variables[202] = 1.0/(1.0+exp((variables[21]+28.6)/17.1)); - variables[201] = 1.0/(100.0*exp(-variables[21]/54.645)+656.0*exp(variables[21]/106.157)); - rates[28] = (variables[202]-states[28])/variables[201]; - variables[207] = sqrt(1.0/(1.0+exp(-(variables[21]+0.6383-variables[206])/10.7071))); - variables[209] = 28.0/(1.0+exp(-(variables[21]-40.0-variables[206])/3.0)); - variables[210] = 1.0*exp(-(variables[21]-variables[206]-5.0)/25.0); - variables[208] = 1.0/(variables[209]+variables[210]); - rates[31] = (variables[207]-states[31])/variables[208]; - variables[214] = 10.0*exp(0.0133*(variables[21]+40.0)); - variables[215] = variables[213]/(variables[213]+variables[214]); - variables[216] = 1.0/(variables[213]+variables[214]); - rates[32] = (variables[215]-states[32])/variables[216]; + algebraic[5] = states[1]; + algebraic[142] = computedConstants[3]*log((constants[4]+0.12*constants[7])/(algebraic[5]+0.12*constants[8])); + algebraic[121] = ((voi > constants[124]) && (voi < constants[124]+constants[125]))?constants[123]:constants[126]; + algebraic[21] = (constants[122] >= 1.0)?algebraic[121]:states[15]; + algebraic[143] = constants[144]*pow(states[18], 3.0)*states[17]*(algebraic[21]-algebraic[142]); + algebraic[145] = constants[146]*pow(states[18], 3.0)*(algebraic[21]-algebraic[142]); + algebraic[12] = algebraic[143]+algebraic[145]; + algebraic[15] = 0.0000185*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computedConstants[3])))*(algebraic[5]-constants[4]*exp(-1.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; + algebraic[2] = computedConstants[3]*log(constants[4]/algebraic[5]); + algebraic[16] = states[16]*computedConstants[133]*(algebraic[21]-algebraic[2])*(1.0-constants[135]); + algebraic[14] = computedConstants[20]*constants[24]*pow(1.0+pow(constants[23]/constants[7], 1.2), -1.0)*pow(1.0+pow(constants[22]/algebraic[5], 1.3), -1.0)*pow(1.0+exp(-(algebraic[21]-algebraic[2]+110.0)/20.0), -1.0); + algebraic[50] = 1.0+constants[10]/constants[48]*(1.0+exp(constants[49]*algebraic[21]/computedConstants[3]))+constants[4]/constants[51]*(1.0+constants[4]/constants[52]*(1.0+constants[4]/constants[47])); + algebraic[27] = constants[10]/constants[48]*exp(constants[49]*algebraic[21]/computedConstants[3])/algebraic[50]; + algebraic[42] = 1.0+states[0]/constants[40]*(1.0+exp(-constants[41]*algebraic[21]/computedConstants[3])+algebraic[5]/constants[46])+algebraic[5]/constants[43]*(1.0+algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])); + algebraic[29] = states[0]/constants[40]*exp(-constants[41]*algebraic[21]/computedConstants[3])/algebraic[42]; + algebraic[36] = algebraic[5]/(constants[39]+algebraic[5]); + algebraic[37] = exp(constants[45]*algebraic[21]/(2.0*computedConstants[3])); + algebraic[33] = exp(-constants[45]*algebraic[21]/(2.0*computedConstants[3])); + algebraic[38] = algebraic[5]/constants[43]*algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])*exp(constants[45]*algebraic[21]/(2.0*computedConstants[3]))/algebraic[42]; + algebraic[26] = algebraic[37]*algebraic[36]*(algebraic[38]+algebraic[29])+algebraic[33]*algebraic[29]*(computedConstants[35]+algebraic[37]); + algebraic[34] = constants[4]/constants[51]*constants[4]/constants[52]*(1.0+constants[4]/constants[47])*exp(-constants[45]*algebraic[21]/(2.0*computedConstants[3]))/algebraic[50]; + algebraic[28] = algebraic[33]*computedConstants[35]*(algebraic[34]+algebraic[27])+algebraic[27]*algebraic[37]*(algebraic[36]+algebraic[33]); + algebraic[31] = algebraic[34]*computedConstants[35]*(algebraic[38]+algebraic[29])+algebraic[38]*algebraic[27]*(computedConstants[35]+algebraic[37]); + algebraic[32] = algebraic[38]*algebraic[36]*(algebraic[34]+algebraic[27])+algebraic[29]*algebraic[34]*(algebraic[36]+algebraic[33]); + algebraic[13] = (1.0-constants[25])*constants[30]*(algebraic[26]*algebraic[27]-algebraic[28]*algebraic[29])/(algebraic[28]+algebraic[26]+algebraic[32]+algebraic[31]); + rates[1] = (1.0-constants[11])*-1.0*(algebraic[12]+algebraic[16]+algebraic[15]+3.0*algebraic[14]+3.0*algebraic[13])/(1.0*(computedConstants[18]+computedConstants[19])*constants[17]); + algebraic[56] = constants[57]-(constants[57]-constants[58])/(1.0+pow(constants[59]/states[2], constants[60])); + algebraic[63] = constants[64]*algebraic[56]; + algebraic[61] = constants[62]/algebraic[56]; + rates[4] = constants[65]*states[5]-algebraic[63]*states[0]*states[4]-(algebraic[61]*pow(states[0], 2.0)*states[4]-constants[66]*states[3]); + rates[3] = algebraic[61]*pow(states[0], 2.0)*states[4]-constants[66]*states[3]-(algebraic[63]*states[0]*states[3]-constants[65]*states[6]); + rates[6] = algebraic[63]*states[0]*states[3]-constants[65]*states[6]-(constants[66]*states[6]-algebraic[61]*pow(states[0], 2.0)*states[5]); + rates[5] = constants[66]*states[6]-algebraic[61]*pow(states[0], 2.0)*states[5]-(constants[65]*states[5]-algebraic[63]*states[0]*states[4]); + algebraic[78] = constants[79]*states[7]*(1.0-states[9])-constants[80]*states[9]; + rates[9] = algebraic[78]; + algebraic[81] = constants[82]*states[7]*(1.0-(states[10]+states[11]))-constants[83]*states[10]; + rates[10] = algebraic[81]; + algebraic[84] = constants[85]*constants[86]*(1.0-(states[10]+states[11]))-constants[87]*states[11]; + rates[11] = algebraic[84]; + algebraic[88] = constants[89]*states[7]*(1.0-states[12])-constants[90]*states[12]; + rates[12] = algebraic[88]; + algebraic[91] = constants[89]*states[0]*(1.0-states[13])-constants[90]*states[13]; + rates[13] = algebraic[91]; + algebraic[92] = constants[93]*states[2]*(1.0-states[14])-constants[94]*states[14]; + rates[14] = algebraic[92]; + algebraic[71] = (states[0]-states[7])/constants[72]; + algebraic[73] = computedConstants[69]/(1.0+exp((-states[7]+constants[74])/constants[75])); + rates[7] = 1.0*(algebraic[71]*computedConstants[19]-algebraic[73]*computedConstants[99])/computedConstants[18]-(constants[97]*algebraic[88]+constants[95]*algebraic[78]+constants[96]*algebraic[81]); + algebraic[53] = constants[54]*states[3]*(states[2]-states[0]); + algebraic[101] = 2.0*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)*2.0/computedConstants[3])))*(states[0]-constants[10]*exp(-2.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; + algebraic[102] = 2.0*constants[184]*algebraic[21]/(computedConstants[3]*(1.0-exp(-1.0*algebraic[21]*2.0/computedConstants[3])))*(states[0]-constants[10]*exp(-2.0*algebraic[21]/computedConstants[3]))*states[25]*states[24]; + rates[0] = algebraic[53]*computedConstants[100]/computedConstants[19]-((algebraic[101]+algebraic[102]-2.0*algebraic[13])/(2.0*constants[17]*computedConstants[19])+algebraic[71]+constants[97]*algebraic[91]); + algebraic[76] = (states[8]-states[2])/constants[77]; + rates[8] = algebraic[73]-algebraic[76]*computedConstants[100]/computedConstants[99]; + rates[2] = algebraic[76]-(algebraic[53]+constants[98]*algebraic[92]); + algebraic[136] = states[16]*computedConstants[134]*(algebraic[21]-computedConstants[6])*(1.0-constants[135]); + algebraic[111] = algebraic[16]+algebraic[136]; + algebraic[112] = constants[157]*states[20]*states[19]*(algebraic[21]-computedConstants[6]); + algebraic[113] = (constants[0] > 0.0)?constants[211]*constants[212]*(algebraic[21]-computedConstants[6])*(1.0+exp((algebraic[21]+20.0)/20.0))*states[32]:0.0; + algebraic[164] = 0.000365*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computedConstants[3])))*(constants[8]-constants[7]*exp(-1.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; + algebraic[114] = (algebraic[101]+algebraic[164]+algebraic[15])*(1.0-computedConstants[165])*1.0*computedConstants[162]; + algebraic[115] = constants[190]*(algebraic[21]-computedConstants[6])*states[27]*states[26]; + algebraic[205] = computedConstants[3]*log((constants[7]+0.12*constants[4])/(constants[8]+0.12*algebraic[5])); + algebraic[116] = computedConstants[203]*(algebraic[21]-algebraic[205])*pow(states[31], 2.0); + algebraic[117] = constants[195]*(algebraic[21]-computedConstants[6])*(0.9*states[29]+0.1*states[30])*states[28]; + algebraic[110] = algebraic[111]+algebraic[117]+algebraic[116]+algebraic[115]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[114]+algebraic[102]+algebraic[113]+algebraic[112]; + rates[15] = -algebraic[110]/constants[118]; + algebraic[140] = (algebraic[21] < -(80.0-computedConstants[137]-computedConstants[138]-constants[141]))?0.01329+0.99921/(1.0+exp((algebraic[21]+97.134-computedConstants[137]-computedConstants[138]-constants[141])/8.1752)):0.0002501*exp(-(algebraic[21]-computedConstants[137]-computedConstants[138]-constants[141])/12.861); + algebraic[139] = 1.0/(0.36*(algebraic[21]+148.8-computedConstants[137]-computedConstants[138])/(exp(0.066*(algebraic[21]+148.8-computedConstants[137]-computedConstants[138]))-1.0)+0.1*(algebraic[21]+87.3-computedConstants[137]-computedConstants[138])/(1.0-exp(-0.2*(algebraic[21]+87.3-computedConstants[137]-computedConstants[138]))))-0.054; + rates[16] = (algebraic[140]-states[16])/algebraic[139]; + algebraic[147] = 1.0/(1.0+exp(-(algebraic[21]+42.0504)/8.3106)); + algebraic[148] = algebraic[21]+41.0; + algebraic[149] = (fabs(algebraic[148]) < constants[150])?2000.0:200.0*algebraic[148]/(1.0-exp(-0.1*algebraic[148])); + algebraic[151] = 8000.0*exp(-0.056*(algebraic[21]+66.0)); + algebraic[152] = 1.0/(algebraic[149]+algebraic[151]); + rates[18] = (algebraic[147]-states[18])/algebraic[152]; + algebraic[153] = 1.0/(1.0+exp((algebraic[21]+69.804)/4.4565)); + algebraic[154] = 20.0*exp(-0.125*(algebraic[21]+75.0)); + algebraic[155] = 2000.0/(320.0*exp(-0.1*(algebraic[21]+75.0))+1.0); + algebraic[156] = 1.0/(algebraic[154]+algebraic[155]); + rates[17] = (algebraic[153]-states[17])/algebraic[156]; + algebraic[158] = 1.0/(1.0+exp((algebraic[21]+6.0)/-8.6)); + algebraic[159] = 0.009/(1.0+exp((algebraic[21]+5.0)/12.0))+0.0005; + rates[20] = (algebraic[158]-states[20])/algebraic[159]; + algebraic[160] = 1.0/(1.0+exp((algebraic[21]+7.5)/10.0)); + algebraic[161] = 0.59/(1.0+exp((algebraic[21]+60.0)/10.0))+3.05; + rates[19] = (algebraic[160]-states[19])/algebraic[161]; + algebraic[168] = 1.0/(1.0+exp(-(algebraic[21]-constants[169]-computedConstants[166])/(constants[170]*(1.0+computedConstants[167]/100.0)))); + algebraic[174] = (algebraic[21] == -41.8)?-41.80001:(algebraic[21] == 0.0)?0.0:(algebraic[21] == -6.8)?-6.80001:algebraic[21]; + algebraic[172] = -0.02839*(algebraic[174]+41.8)/(exp(-(algebraic[174]+41.8)/2.5)-1.0)-0.0849*(algebraic[174]+6.8)/(exp(-(algebraic[174]+6.8)/4.8)-1.0); + algebraic[175] = (algebraic[21] == -1.8)?-1.80001:algebraic[21]; + algebraic[173] = 0.01143*(algebraic[175]+1.8)/(exp((algebraic[175]+1.8)/2.5)-1.0); + algebraic[171] = 0.001/(algebraic[172]+algebraic[173]); + rates[23] = (algebraic[168]-states[23])/algebraic[171]; + algebraic[176] = 1.0/(1.0+exp((algebraic[21]+37.4+constants[177])/(5.3+constants[178]))); + algebraic[179] = 0.001*(44.3+230.0*exp(-pow((algebraic[21]+36.0)/10.0, 2.0))); + rates[22] = (algebraic[176]-states[22])/algebraic[179]; + algebraic[180] = constants[181]/(constants[181]+states[0]); + algebraic[182] = 0.001*algebraic[180]/constants[183]; + rates[21] = (algebraic[180]-states[21])/algebraic[182]; + algebraic[185] = 1.0/(1.0+exp(-(algebraic[21]+38.3)/5.5)); + algebraic[186] = 0.001/(1.068*exp((algebraic[21]+38.3)/30.0)+1.068*exp(-(algebraic[21]+38.3)/30.0)); + rates[25] = (algebraic[185]-states[25])/algebraic[186]; + algebraic[187] = 1.0/(1.0+exp((algebraic[21]+58.7)/3.8)); + algebraic[188] = 1.0/(16.67*exp(-(algebraic[21]+75.0)/83.3)+16.67*exp((algebraic[21]+75.0)/15.38))+constants[189]; + rates[24] = (algebraic[187]-states[24])/algebraic[188]; + algebraic[191] = 1.0/(1.0+exp((algebraic[21]+49.0)/13.0)); + algebraic[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[21]+44.0))+0.065*exp(0.1*(algebraic[21]+45.93)))+10.1); + rates[27] = (algebraic[191]-states[27])/algebraic[192]; + algebraic[193] = 1.0/(1.0+exp(-(algebraic[21]-19.3)/15.0)); + algebraic[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[21]+30.61))+0.369*exp(-0.12*(algebraic[21]+23.84)))+2.98); + rates[26] = (algebraic[193]-states[26])/algebraic[194]; + algebraic[198] = 1.0/(1.0+exp(-(algebraic[21]+10.0144)/7.6607)); + algebraic[199] = 0.84655354/(4.2*exp(algebraic[21]/17.0)+0.15*exp(-algebraic[21]/21.6)); + rates[30] = (algebraic[198]-states[30])/algebraic[199]; + algebraic[200] = 1.0/(30.0*exp(algebraic[21]/10.0)+exp(-algebraic[21]/12.0)); + rates[29] = (algebraic[198]-states[29])/algebraic[200]; + algebraic[202] = 1.0/(1.0+exp((algebraic[21]+28.6)/17.1)); + algebraic[201] = 1.0/(100.0*exp(-algebraic[21]/54.645)+656.0*exp(algebraic[21]/106.157)); + rates[28] = (algebraic[202]-states[28])/algebraic[201]; + algebraic[207] = sqrt(1.0/(1.0+exp(-(algebraic[21]+0.6383-computedConstants[206])/10.7071))); + algebraic[209] = 28.0/(1.0+exp(-(algebraic[21]-40.0-computedConstants[206])/3.0)); + algebraic[210] = 1.0*exp(-(algebraic[21]-computedConstants[206]-5.0)/25.0); + algebraic[208] = 1.0/(algebraic[209]+algebraic[210]); + rates[31] = (algebraic[207]-states[31])/algebraic[208]; + algebraic[214] = 10.0*exp(0.0133*(algebraic[21]+40.0)); + algebraic[215] = computedConstants[213]/(computedConstants[213]+algebraic[214]); + algebraic[216] = 1.0/(computedConstants[213]+algebraic[214]); + rates[32] = (algebraic[215]-states[32])/algebraic[216]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[5] = states[1]; - variables[2] = variables[3]*log(variables[4]/variables[5]); - variables[9] = 0.5*variables[3]*log(variables[10]/states[0]); - variables[21] = (variables[122] >= 1.0)?variables[121]:states[15]; - variables[14] = variables[20]*variables[24]*pow(1.0+pow(variables[23]/variables[7], 1.2), -1.0)*pow(1.0+pow(variables[22]/variables[5], 1.3), -1.0)*pow(1.0+exp(-(variables[21]-variables[2]+110.0)/20.0), -1.0); - variables[50] = 1.0+variables[10]/variables[48]*(1.0+exp(variables[49]*variables[21]/variables[3]))+variables[4]/variables[51]*(1.0+variables[4]/variables[52]*(1.0+variables[4]/variables[47])); - variables[27] = variables[10]/variables[48]*exp(variables[49]*variables[21]/variables[3])/variables[50]; - variables[42] = 1.0+states[0]/variables[40]*(1.0+exp(-variables[41]*variables[21]/variables[3])+variables[5]/variables[46])+variables[5]/variables[43]*(1.0+variables[5]/variables[44]*(1.0+variables[5]/variables[39])); - variables[29] = states[0]/variables[40]*exp(-variables[41]*variables[21]/variables[3])/variables[42]; - variables[36] = variables[5]/(variables[39]+variables[5]); - variables[37] = exp(variables[45]*variables[21]/(2.0*variables[3])); - variables[33] = exp(-variables[45]*variables[21]/(2.0*variables[3])); - variables[38] = variables[5]/variables[43]*variables[5]/variables[44]*(1.0+variables[5]/variables[39])*exp(variables[45]*variables[21]/(2.0*variables[3]))/variables[42]; - variables[26] = variables[37]*variables[36]*(variables[38]+variables[29])+variables[33]*variables[29]*(variables[35]+variables[37]); - variables[34] = variables[4]/variables[51]*variables[4]/variables[52]*(1.0+variables[4]/variables[47])*exp(-variables[45]*variables[21]/(2.0*variables[3]))/variables[50]; - variables[28] = variables[33]*variables[35]*(variables[34]+variables[27])+variables[27]*variables[37]*(variables[36]+variables[33]); - variables[31] = variables[34]*variables[35]*(variables[38]+variables[29])+variables[38]*variables[27]*(variables[35]+variables[37]); - variables[32] = variables[38]*variables[36]*(variables[34]+variables[27])+variables[29]*variables[34]*(variables[36]+variables[33]); - variables[13] = (1.0-variables[25])*variables[30]*(variables[26]*variables[27]-variables[28]*variables[29])/(variables[28]+variables[26]+variables[32]+variables[31]); - variables[53] = variables[54]*states[3]*(states[2]-states[0]); - variables[55] = states[2]-states[0]; - variables[56] = variables[57]-(variables[57]-variables[58])/(1.0+pow(variables[59]/states[2], variables[60])); - variables[61] = variables[62]/variables[56]; - variables[63] = variables[64]*variables[56]; - variables[67] = states[4]+states[3]+states[6]+states[5]; - variables[71] = (states[0]-states[7])/variables[72]; - variables[73] = variables[69]/(1.0+exp((-states[7]+variables[74])/variables[75])); - variables[76] = (states[8]-states[2])/variables[77]; - variables[78] = variables[79]*states[7]*(1.0-states[9])-variables[80]*states[9]; - variables[81] = variables[82]*states[7]*(1.0-(states[10]+states[11]))-variables[83]*states[10]; - variables[84] = variables[85]*variables[86]*(1.0-(states[10]+states[11]))-variables[87]*states[11]; - variables[88] = variables[89]*states[7]*(1.0-states[12])-variables[90]*states[12]; - variables[91] = variables[89]*states[0]*(1.0-states[13])-variables[90]*states[13]; - variables[92] = variables[93]*states[2]*(1.0-states[14])-variables[94]*states[14]; - variables[16] = states[16]*variables[133]*(variables[21]-variables[2])*(1.0-variables[135]); - variables[136] = states[16]*variables[134]*(variables[21]-variables[6])*(1.0-variables[135]); - variables[111] = variables[16]+variables[136]; - variables[112] = variables[157]*states[20]*states[19]*(variables[21]-variables[6]); - variables[113] = (variables[0] > 0.0)?variables[211]*variables[212]*(variables[21]-variables[6])*(1.0+exp((variables[21]+20.0)/20.0))*states[32]:0.0; - variables[102] = 2.0*variables[184]*variables[21]/(variables[3]*(1.0-exp(-1.0*variables[21]*2.0/variables[3])))*(states[0]-variables[10]*exp(-2.0*variables[21]/variables[3]))*states[25]*states[24]; - variables[101] = 2.0*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)*2.0/variables[3])))*(states[0]-variables[10]*exp(-2.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21]; - variables[15] = 0.0000185*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)/variables[3])))*(variables[5]-variables[4]*exp(-1.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21]; - variables[164] = 0.000365*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)/variables[3])))*(variables[8]-variables[7]*exp(-1.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21]; - variables[114] = (variables[101]+variables[164]+variables[15])*(1.0-variables[165])*1.0*variables[162]; - variables[142] = variables[3]*log((variables[4]+0.12*variables[7])/(variables[5]+0.12*variables[8])); - variables[143] = variables[144]*pow(states[18], 3.0)*states[17]*(variables[21]-variables[142]); - variables[145] = variables[146]*pow(states[18], 3.0)*(variables[21]-variables[142]); - variables[12] = variables[143]+variables[145]; - variables[115] = variables[190]*(variables[21]-variables[6])*states[27]*states[26]; - variables[205] = variables[3]*log((variables[7]+0.12*variables[4])/(variables[8]+0.12*variables[5])); - variables[116] = variables[203]*(variables[21]-variables[205])*pow(states[31], 2.0); - variables[117] = variables[195]*(variables[21]-variables[6])*(0.9*states[29]+0.1*states[30])*states[28]; - variables[110] = variables[111]+variables[117]+variables[116]+variables[115]+variables[14]+variables[13]+variables[12]+variables[114]+variables[102]+variables[113]+variables[112]; - variables[139] = 1.0/(0.36*(variables[21]+148.8-variables[137]-variables[138])/(exp(0.066*(variables[21]+148.8-variables[137]-variables[138]))-1.0)+0.1*(variables[21]+87.3-variables[137]-variables[138])/(1.0-exp(-0.2*(variables[21]+87.3-variables[137]-variables[138]))))-0.054; - variables[140] = (variables[21] < -(80.0-variables[137]-variables[138]-variables[141]))?0.01329+0.99921/(1.0+exp((variables[21]+97.134-variables[137]-variables[138]-variables[141])/8.1752)):0.0002501*exp(-(variables[21]-variables[137]-variables[138]-variables[141])/12.861); - variables[147] = 1.0/(1.0+exp(-(variables[21]+42.0504)/8.3106)); - variables[148] = variables[21]+41.0; - variables[149] = (fabs(variables[148]) < variables[150])?2000.0:200.0*variables[148]/(1.0-exp(-0.1*variables[148])); - variables[151] = 8000.0*exp(-0.056*(variables[21]+66.0)); - variables[152] = 1.0/(variables[149]+variables[151]); - variables[153] = 1.0/(1.0+exp((variables[21]+69.804)/4.4565)); - variables[154] = 20.0*exp(-0.125*(variables[21]+75.0)); - variables[155] = 2000.0/(320.0*exp(-0.1*(variables[21]+75.0))+1.0); - variables[156] = 1.0/(variables[154]+variables[155]); - variables[158] = 1.0/(1.0+exp((variables[21]+6.0)/-8.6)); - variables[159] = 0.009/(1.0+exp((variables[21]+5.0)/12.0))+0.0005; - variables[160] = 1.0/(1.0+exp((variables[21]+7.5)/10.0)); - variables[161] = 0.59/(1.0+exp((variables[21]+60.0)/10.0))+3.05; - variables[168] = 1.0/(1.0+exp(-(variables[21]-variables[169]-variables[166])/(variables[170]*(1.0+variables[167]/100.0)))); - variables[174] = (variables[21] == -41.8)?-41.80001:(variables[21] == 0.0)?0.0:(variables[21] == -6.8)?-6.80001:variables[21]; - variables[172] = -0.02839*(variables[174]+41.8)/(exp(-(variables[174]+41.8)/2.5)-1.0)-0.0849*(variables[174]+6.8)/(exp(-(variables[174]+6.8)/4.8)-1.0); - variables[175] = (variables[21] == -1.8)?-1.80001:variables[21]; - variables[173] = 0.01143*(variables[175]+1.8)/(exp((variables[175]+1.8)/2.5)-1.0); - variables[171] = 0.001/(variables[172]+variables[173]); - variables[176] = 1.0/(1.0+exp((variables[21]+37.4+variables[177])/(5.3+variables[178]))); - variables[179] = 0.001*(44.3+230.0*exp(-pow((variables[21]+36.0)/10.0, 2.0))); - variables[180] = variables[181]/(variables[181]+states[0]); - variables[182] = 0.001*variables[180]/variables[183]; - variables[185] = 1.0/(1.0+exp(-(variables[21]+38.3)/5.5)); - variables[186] = 0.001/(1.068*exp((variables[21]+38.3)/30.0)+1.068*exp(-(variables[21]+38.3)/30.0)); - variables[187] = 1.0/(1.0+exp((variables[21]+58.7)/3.8)); - variables[188] = 1.0/(16.67*exp(-(variables[21]+75.0)/83.3)+16.67*exp((variables[21]+75.0)/15.38))+variables[189]; - variables[191] = 1.0/(1.0+exp((variables[21]+49.0)/13.0)); - variables[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(variables[21]+44.0))+0.065*exp(0.1*(variables[21]+45.93)))+10.1); - variables[193] = 1.0/(1.0+exp(-(variables[21]-19.3)/15.0)); - variables[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(variables[21]+30.61))+0.369*exp(-0.12*(variables[21]+23.84)))+2.98); - variables[196] = 1.0/(1.0+exp(-(variables[21]+23.2)/6.6))/(0.84655354/(37.2*exp(variables[21]/11.9)+0.96*exp(-variables[21]/18.5))); - variables[197] = 4.0*((37.2*exp(variables[21]/15.9)+0.96*exp(-variables[21]/22.5))/0.84655354-1.0/(1.0+exp(-(variables[21]+23.2)/10.6))/(0.84655354/(37.2*exp(variables[21]/15.9)+0.96*exp(-variables[21]/22.5)))); - variables[198] = 1.0/(1.0+exp(-(variables[21]+10.0144)/7.6607)); - variables[199] = 0.84655354/(4.2*exp(variables[21]/17.0)+0.15*exp(-variables[21]/21.6)); - variables[200] = 1.0/(30.0*exp(variables[21]/10.0)+exp(-variables[21]/12.0)); - variables[201] = 1.0/(100.0*exp(-variables[21]/54.645)+656.0*exp(variables[21]/106.157)); - variables[202] = 1.0/(1.0+exp((variables[21]+28.6)/17.1)); - variables[207] = sqrt(1.0/(1.0+exp(-(variables[21]+0.6383-variables[206])/10.7071))); - variables[209] = 28.0/(1.0+exp(-(variables[21]-40.0-variables[206])/3.0)); - variables[210] = 1.0*exp(-(variables[21]-variables[206]-5.0)/25.0); - variables[208] = 1.0/(variables[209]+variables[210]); - variables[214] = 10.0*exp(0.0133*(variables[21]+40.0)); - variables[215] = variables[213]/(variables[213]+variables[214]); - variables[216] = 1.0/(variables[213]+variables[214]); + algebraic[5] = states[1]; + algebraic[2] = computedConstants[3]*log(constants[4]/algebraic[5]); + algebraic[9] = 0.5*computedConstants[3]*log(constants[10]/states[0]); + algebraic[21] = (constants[122] >= 1.0)?algebraic[121]:states[15]; + algebraic[14] = computedConstants[20]*constants[24]*pow(1.0+pow(constants[23]/constants[7], 1.2), -1.0)*pow(1.0+pow(constants[22]/algebraic[5], 1.3), -1.0)*pow(1.0+exp(-(algebraic[21]-algebraic[2]+110.0)/20.0), -1.0); + algebraic[50] = 1.0+constants[10]/constants[48]*(1.0+exp(constants[49]*algebraic[21]/computedConstants[3]))+constants[4]/constants[51]*(1.0+constants[4]/constants[52]*(1.0+constants[4]/constants[47])); + algebraic[27] = constants[10]/constants[48]*exp(constants[49]*algebraic[21]/computedConstants[3])/algebraic[50]; + algebraic[42] = 1.0+states[0]/constants[40]*(1.0+exp(-constants[41]*algebraic[21]/computedConstants[3])+algebraic[5]/constants[46])+algebraic[5]/constants[43]*(1.0+algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])); + algebraic[29] = states[0]/constants[40]*exp(-constants[41]*algebraic[21]/computedConstants[3])/algebraic[42]; + algebraic[36] = algebraic[5]/(constants[39]+algebraic[5]); + algebraic[37] = exp(constants[45]*algebraic[21]/(2.0*computedConstants[3])); + algebraic[33] = exp(-constants[45]*algebraic[21]/(2.0*computedConstants[3])); + algebraic[38] = algebraic[5]/constants[43]*algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])*exp(constants[45]*algebraic[21]/(2.0*computedConstants[3]))/algebraic[42]; + algebraic[26] = algebraic[37]*algebraic[36]*(algebraic[38]+algebraic[29])+algebraic[33]*algebraic[29]*(computedConstants[35]+algebraic[37]); + algebraic[34] = constants[4]/constants[51]*constants[4]/constants[52]*(1.0+constants[4]/constants[47])*exp(-constants[45]*algebraic[21]/(2.0*computedConstants[3]))/algebraic[50]; + algebraic[28] = algebraic[33]*computedConstants[35]*(algebraic[34]+algebraic[27])+algebraic[27]*algebraic[37]*(algebraic[36]+algebraic[33]); + algebraic[31] = algebraic[34]*computedConstants[35]*(algebraic[38]+algebraic[29])+algebraic[38]*algebraic[27]*(computedConstants[35]+algebraic[37]); + algebraic[32] = algebraic[38]*algebraic[36]*(algebraic[34]+algebraic[27])+algebraic[29]*algebraic[34]*(algebraic[36]+algebraic[33]); + algebraic[13] = (1.0-constants[25])*constants[30]*(algebraic[26]*algebraic[27]-algebraic[28]*algebraic[29])/(algebraic[28]+algebraic[26]+algebraic[32]+algebraic[31]); + algebraic[53] = constants[54]*states[3]*(states[2]-states[0]); + algebraic[55] = states[2]-states[0]; + algebraic[56] = constants[57]-(constants[57]-constants[58])/(1.0+pow(constants[59]/states[2], constants[60])); + algebraic[61] = constants[62]/algebraic[56]; + algebraic[63] = constants[64]*algebraic[56]; + algebraic[67] = states[4]+states[3]+states[6]+states[5]; + algebraic[71] = (states[0]-states[7])/constants[72]; + algebraic[73] = computedConstants[69]/(1.0+exp((-states[7]+constants[74])/constants[75])); + algebraic[76] = (states[8]-states[2])/constants[77]; + algebraic[78] = constants[79]*states[7]*(1.0-states[9])-constants[80]*states[9]; + algebraic[81] = constants[82]*states[7]*(1.0-(states[10]+states[11]))-constants[83]*states[10]; + algebraic[84] = constants[85]*constants[86]*(1.0-(states[10]+states[11]))-constants[87]*states[11]; + algebraic[88] = constants[89]*states[7]*(1.0-states[12])-constants[90]*states[12]; + algebraic[91] = constants[89]*states[0]*(1.0-states[13])-constants[90]*states[13]; + algebraic[92] = constants[93]*states[2]*(1.0-states[14])-constants[94]*states[14]; + algebraic[16] = states[16]*computedConstants[133]*(algebraic[21]-algebraic[2])*(1.0-constants[135]); + algebraic[136] = states[16]*computedConstants[134]*(algebraic[21]-computedConstants[6])*(1.0-constants[135]); + algebraic[111] = algebraic[16]+algebraic[136]; + algebraic[112] = constants[157]*states[20]*states[19]*(algebraic[21]-computedConstants[6]); + algebraic[113] = (constants[0] > 0.0)?constants[211]*constants[212]*(algebraic[21]-computedConstants[6])*(1.0+exp((algebraic[21]+20.0)/20.0))*states[32]:0.0; + algebraic[102] = 2.0*constants[184]*algebraic[21]/(computedConstants[3]*(1.0-exp(-1.0*algebraic[21]*2.0/computedConstants[3])))*(states[0]-constants[10]*exp(-2.0*algebraic[21]/computedConstants[3]))*states[25]*states[24]; + algebraic[101] = 2.0*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)*2.0/computedConstants[3])))*(states[0]-constants[10]*exp(-2.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; + algebraic[15] = 0.0000185*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computedConstants[3])))*(algebraic[5]-constants[4]*exp(-1.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; + algebraic[164] = 0.000365*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computedConstants[3])))*(constants[8]-constants[7]*exp(-1.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; + algebraic[114] = (algebraic[101]+algebraic[164]+algebraic[15])*(1.0-computedConstants[165])*1.0*computedConstants[162]; + algebraic[142] = computedConstants[3]*log((constants[4]+0.12*constants[7])/(algebraic[5]+0.12*constants[8])); + algebraic[143] = constants[144]*pow(states[18], 3.0)*states[17]*(algebraic[21]-algebraic[142]); + algebraic[145] = constants[146]*pow(states[18], 3.0)*(algebraic[21]-algebraic[142]); + algebraic[12] = algebraic[143]+algebraic[145]; + algebraic[115] = constants[190]*(algebraic[21]-computedConstants[6])*states[27]*states[26]; + algebraic[205] = computedConstants[3]*log((constants[7]+0.12*constants[4])/(constants[8]+0.12*algebraic[5])); + algebraic[116] = computedConstants[203]*(algebraic[21]-algebraic[205])*pow(states[31], 2.0); + algebraic[117] = constants[195]*(algebraic[21]-computedConstants[6])*(0.9*states[29]+0.1*states[30])*states[28]; + algebraic[110] = algebraic[111]+algebraic[117]+algebraic[116]+algebraic[115]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[114]+algebraic[102]+algebraic[113]+algebraic[112]; + algebraic[139] = 1.0/(0.36*(algebraic[21]+148.8-computedConstants[137]-computedConstants[138])/(exp(0.066*(algebraic[21]+148.8-computedConstants[137]-computedConstants[138]))-1.0)+0.1*(algebraic[21]+87.3-computedConstants[137]-computedConstants[138])/(1.0-exp(-0.2*(algebraic[21]+87.3-computedConstants[137]-computedConstants[138]))))-0.054; + algebraic[140] = (algebraic[21] < -(80.0-computedConstants[137]-computedConstants[138]-constants[141]))?0.01329+0.99921/(1.0+exp((algebraic[21]+97.134-computedConstants[137]-computedConstants[138]-constants[141])/8.1752)):0.0002501*exp(-(algebraic[21]-computedConstants[137]-computedConstants[138]-constants[141])/12.861); + algebraic[147] = 1.0/(1.0+exp(-(algebraic[21]+42.0504)/8.3106)); + algebraic[148] = algebraic[21]+41.0; + algebraic[149] = (fabs(algebraic[148]) < constants[150])?2000.0:200.0*algebraic[148]/(1.0-exp(-0.1*algebraic[148])); + algebraic[151] = 8000.0*exp(-0.056*(algebraic[21]+66.0)); + algebraic[152] = 1.0/(algebraic[149]+algebraic[151]); + algebraic[153] = 1.0/(1.0+exp((algebraic[21]+69.804)/4.4565)); + algebraic[154] = 20.0*exp(-0.125*(algebraic[21]+75.0)); + algebraic[155] = 2000.0/(320.0*exp(-0.1*(algebraic[21]+75.0))+1.0); + algebraic[156] = 1.0/(algebraic[154]+algebraic[155]); + algebraic[158] = 1.0/(1.0+exp((algebraic[21]+6.0)/-8.6)); + algebraic[159] = 0.009/(1.0+exp((algebraic[21]+5.0)/12.0))+0.0005; + algebraic[160] = 1.0/(1.0+exp((algebraic[21]+7.5)/10.0)); + algebraic[161] = 0.59/(1.0+exp((algebraic[21]+60.0)/10.0))+3.05; + algebraic[168] = 1.0/(1.0+exp(-(algebraic[21]-constants[169]-computedConstants[166])/(constants[170]*(1.0+computedConstants[167]/100.0)))); + algebraic[174] = (algebraic[21] == -41.8)?-41.80001:(algebraic[21] == 0.0)?0.0:(algebraic[21] == -6.8)?-6.80001:algebraic[21]; + algebraic[172] = -0.02839*(algebraic[174]+41.8)/(exp(-(algebraic[174]+41.8)/2.5)-1.0)-0.0849*(algebraic[174]+6.8)/(exp(-(algebraic[174]+6.8)/4.8)-1.0); + algebraic[175] = (algebraic[21] == -1.8)?-1.80001:algebraic[21]; + algebraic[173] = 0.01143*(algebraic[175]+1.8)/(exp((algebraic[175]+1.8)/2.5)-1.0); + algebraic[171] = 0.001/(algebraic[172]+algebraic[173]); + algebraic[176] = 1.0/(1.0+exp((algebraic[21]+37.4+constants[177])/(5.3+constants[178]))); + algebraic[179] = 0.001*(44.3+230.0*exp(-pow((algebraic[21]+36.0)/10.0, 2.0))); + algebraic[180] = constants[181]/(constants[181]+states[0]); + algebraic[182] = 0.001*algebraic[180]/constants[183]; + algebraic[185] = 1.0/(1.0+exp(-(algebraic[21]+38.3)/5.5)); + algebraic[186] = 0.001/(1.068*exp((algebraic[21]+38.3)/30.0)+1.068*exp(-(algebraic[21]+38.3)/30.0)); + algebraic[187] = 1.0/(1.0+exp((algebraic[21]+58.7)/3.8)); + algebraic[188] = 1.0/(16.67*exp(-(algebraic[21]+75.0)/83.3)+16.67*exp((algebraic[21]+75.0)/15.38))+constants[189]; + algebraic[191] = 1.0/(1.0+exp((algebraic[21]+49.0)/13.0)); + algebraic[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[21]+44.0))+0.065*exp(0.1*(algebraic[21]+45.93)))+10.1); + algebraic[193] = 1.0/(1.0+exp(-(algebraic[21]-19.3)/15.0)); + algebraic[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[21]+30.61))+0.369*exp(-0.12*(algebraic[21]+23.84)))+2.98); + algebraic[196] = 1.0/(1.0+exp(-(algebraic[21]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraic[21]/11.9)+0.96*exp(-algebraic[21]/18.5))); + algebraic[197] = 4.0*((37.2*exp(algebraic[21]/15.9)+0.96*exp(-algebraic[21]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraic[21]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraic[21]/15.9)+0.96*exp(-algebraic[21]/22.5)))); + algebraic[198] = 1.0/(1.0+exp(-(algebraic[21]+10.0144)/7.6607)); + algebraic[199] = 0.84655354/(4.2*exp(algebraic[21]/17.0)+0.15*exp(-algebraic[21]/21.6)); + algebraic[200] = 1.0/(30.0*exp(algebraic[21]/10.0)+exp(-algebraic[21]/12.0)); + algebraic[201] = 1.0/(100.0*exp(-algebraic[21]/54.645)+656.0*exp(algebraic[21]/106.157)); + algebraic[202] = 1.0/(1.0+exp((algebraic[21]+28.6)/17.1)); + algebraic[207] = sqrt(1.0/(1.0+exp(-(algebraic[21]+0.6383-computedConstants[206])/10.7071))); + algebraic[209] = 28.0/(1.0+exp(-(algebraic[21]-40.0-computedConstants[206])/3.0)); + algebraic[210] = 1.0*exp(-(algebraic[21]-computedConstants[206]-5.0)/25.0); + algebraic[208] = 1.0/(algebraic[209]+algebraic[210]); + algebraic[214] = 10.0*exp(0.0133*(algebraic[21]+40.0)); + algebraic[215] = computedConstants[213]/(computedConstants[213]+algebraic[214]); + algebraic[216] = 1.0/(computedConstants[213]+algebraic[214]); } diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 9831f67e5..109e8280d 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -309,97 +309,97 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 0.0 - variables[1] = 0.0 - variables[4] = 140.0 - variables[7] = 5.4 - variables[8] = 140.0 - variables[10] = 1.8 - variables[11] = 1.0 - variables[17] = 96485.3415 - variables[22] = 14.0 - variables[23] = 1.4 - variables[24] = 0.08105 - variables[25] = 0.0 - variables[30] = 3.343 - variables[39] = 26.44 - variables[40] = 0.0207 - variables[41] = 0.1369 - variables[43] = 395.3 - variables[44] = 2.289 - variables[45] = 0.4315 - variables[46] = 26.44 - variables[47] = 4.663 - variables[48] = 3.663 - variables[49] = 0.0 - variables[51] = 1628.0 - variables[52] = 561.4 - variables[54] = 148041085.1 - variables[57] = 15.0 - variables[58] = 1.0 - variables[59] = 0.45 - variables[60] = 2.5 - variables[62] = 10000.0 - variables[64] = 500.0 - variables[65] = 5.0 - variables[66] = 660.0 - variables[70] = 5.0 - variables[72] = 5.469e-5 - variables[74] = 0.000286113 - variables[75] = 5.0e-5 - variables[77] = 0.04 - variables[79] = 88800.0 - variables[80] = 446.0 - variables[82] = 227700.0 - variables[83] = 7.51 - variables[85] = 2277.0 - variables[86] = 2.5 - variables[87] = 751.0 - variables[89] = 1.642e6 - variables[90] = 542.0 - variables[93] = 175.4 - variables[94] = 445.0 - variables[95] = 0.031 - variables[96] = 0.062 - variables[97] = 0.045 - variables[98] = 10.0 - variables[104] = 67.0 - variables[105] = 3.9 - variables[106] = 0.02 - variables[107] = 0.0012 - variables[108] = 0.46 - variables[109] = 0.0116 - variables[118] = 5.7e-5 - variables[119] = 8314.472 - variables[120] = 310.0 - variables[122] = 0.0 - variables[123] = -35.0 - variables[124] = 0.5 - variables[125] = 0.5 - variables[126] = -45.0 - variables[128] = 0.00427 - variables[129] = 45.0 - variables[131] = 0.5927 - variables[135] = 0.0 - variables[141] = 0.0 - variables[144] = 0.0223 - variables[146] = 0.0 - variables[150] = 1.0e-5 - variables[157] = 0.1539e-3 - variables[163] = 0.4578 - variables[169] = -16.4508 - variables[170] = 4.3371 - variables[177] = 0.0 - variables[178] = 0.0 - variables[181] = 0.000338 - variables[183] = 0.0075 - variables[184] = 0.04132 - variables[189] = 0.0 - variables[190] = 3.5e-3 - variables[195] = 0.00424 - variables[204] = 0.00065 - variables[211] = 1.0 - variables[212] = 0.00345 + constants[0] = 0.0 + constants[1] = 0.0 + constants[4] = 140.0 + constants[7] = 5.4 + constants[8] = 140.0 + constants[10] = 1.8 + constants[11] = 1.0 + constants[17] = 96485.3415 + constants[22] = 14.0 + constants[23] = 1.4 + constants[24] = 0.08105 + constants[25] = 0.0 + constants[30] = 3.343 + constants[39] = 26.44 + constants[40] = 0.0207 + constants[41] = 0.1369 + constants[43] = 395.3 + constants[44] = 2.289 + constants[45] = 0.4315 + constants[46] = 26.44 + constants[47] = 4.663 + constants[48] = 3.663 + constants[49] = 0.0 + constants[51] = 1628.0 + constants[52] = 561.4 + constants[54] = 148041085.1 + constants[57] = 15.0 + constants[58] = 1.0 + constants[59] = 0.45 + constants[60] = 2.5 + constants[62] = 10000.0 + constants[64] = 500.0 + constants[65] = 5.0 + constants[66] = 660.0 + constants[70] = 5.0 + constants[72] = 5.469e-5 + constants[74] = 0.000286113 + constants[75] = 5.0e-5 + constants[77] = 0.04 + constants[79] = 88800.0 + constants[80] = 446.0 + constants[82] = 227700.0 + constants[83] = 7.51 + constants[85] = 2277.0 + constants[86] = 2.5 + constants[87] = 751.0 + constants[89] = 1.642e6 + constants[90] = 542.0 + constants[93] = 175.4 + constants[94] = 445.0 + constants[95] = 0.031 + constants[96] = 0.062 + constants[97] = 0.045 + constants[98] = 10.0 + constants[104] = 67.0 + constants[105] = 3.9 + constants[106] = 0.02 + constants[107] = 0.0012 + constants[108] = 0.46 + constants[109] = 0.0116 + constants[118] = 5.7e-5 + constants[119] = 8314.472 + constants[120] = 310.0 + constants[122] = 0.0 + constants[123] = -35.0 + constants[124] = 0.5 + constants[125] = 0.5 + constants[126] = -45.0 + constants[128] = 0.00427 + constants[129] = 45.0 + constants[131] = 0.5927 + constants[135] = 0.0 + constants[141] = 0.0 + constants[144] = 0.0223 + constants[146] = 0.0 + constants[150] = 1.0e-5 + constants[157] = 0.1539e-3 + constants[163] = 0.4578 + constants[169] = -16.4508 + constants[170] = 4.3371 + constants[177] = 0.0 + constants[178] = 0.0 + constants[181] = 0.000338 + constants[183] = 0.0075 + constants[184] = 0.04132 + constants[189] = 0.0 + constants[190] = 3.5e-3 + constants[195] = 0.00424 + constants[204] = 0.00065 + constants[211] = 1.0 + constants[212] = 0.00345 states[0] = 6.226104e-5 states[1] = 5.0 states[2] = 0.409551 @@ -436,263 +436,263 @@ def initialise_variables(states, rates, constants): def compute_computed_constants(constants, computed_constants): - variables[3] = variables[119]*variables[120]/variables[17] - variables[6] = variables[3]*log(variables[7]/variables[8]) - variables[20] = 1.2 if gt_func(variables[1], 0.0) else 1.0 - variables[35] = variables[4]/(variables[47]+variables[4]) - variables[68] = -0.25 if gt_func(variables[1], 0.0) else 0.7*variables[0]/(0.00009+variables[0]) if gt_func(variables[0], 0.0) else 0.0 - variables[69] = variables[70]*(1.0-variables[68]) - variables[103] = 0.000000001*3.14159265358979*pow(variables[105], 2.0)*variables[104] - variables[19] = 0.000000001*2.0*3.14159265358979*variables[106]*(variables[105]-variables[106]/2.0)*variables[104] - variables[100] = variables[107]*variables[103] - variables[18] = variables[108]*variables[103]-variables[19] - variables[99] = variables[109]*variables[103] - variables[127] = variables[128]/(variables[7]/(variables[7]+variables[129])) - variables[130] = variables[127]/(variables[131]+1.0) - variables[132] = variables[131]*variables[130] - variables[133] = variables[132]*variables[7]/(variables[7]+variables[129]) - variables[134] = variables[130]*variables[7]/(variables[7]+variables[129]) - variables[137] = -1.0-9.898*pow(1.0*variables[0], 0.618)/(pow(1.0*variables[0], 0.618)+0.00122423) if gt_func(variables[0], 0.0) else 0.0 - variables[138] = 7.5 if gt_func(variables[1], 0.0) else 0.0 - variables[162] = 1.23 if gt_func(variables[1], 0.0) else 1.0 - variables[165] = 0.31*variables[0]/(variables[0]+0.00009) - variables[166] = -8.0 if gt_func(variables[1], 0.0) else 0.0 - variables[167] = -27.0 if gt_func(variables[1], 0.0) else 0.0 - variables[203] = 1.2*variables[204] if gt_func(variables[1], 0.0) else variables[204] - variables[206] = -14.0 if gt_func(variables[1], 0.0) else 0.0 - variables[213] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*variables[0], 1.6951))+0.025641 + computed_constants[3] = constants[119]*constants[120]/constants[17] + computed_constants[6] = computed_constants[3]*log(constants[7]/constants[8]) + computed_constants[20] = 1.2 if gt_func(constants[1], 0.0) else 1.0 + computed_constants[35] = constants[4]/(constants[47]+constants[4]) + computed_constants[68] = -0.25 if gt_func(constants[1], 0.0) else 0.7*constants[0]/(0.00009+constants[0]) if gt_func(constants[0], 0.0) else 0.0 + computed_constants[69] = constants[70]*(1.0-computed_constants[68]) + computed_constants[103] = 0.000000001*3.14159265358979*pow(constants[105], 2.0)*constants[104] + computed_constants[19] = 0.000000001*2.0*3.14159265358979*constants[106]*(constants[105]-constants[106]/2.0)*constants[104] + computed_constants[100] = constants[107]*computed_constants[103] + computed_constants[18] = constants[108]*computed_constants[103]-computed_constants[19] + computed_constants[99] = constants[109]*computed_constants[103] + computed_constants[127] = constants[128]/(constants[7]/(constants[7]+constants[129])) + computed_constants[130] = computed_constants[127]/(constants[131]+1.0) + computed_constants[132] = constants[131]*computed_constants[130] + computed_constants[133] = computed_constants[132]*constants[7]/(constants[7]+constants[129]) + computed_constants[134] = computed_constants[130]*constants[7]/(constants[7]+constants[129]) + computed_constants[137] = -1.0-9.898*pow(1.0*constants[0], 0.618)/(pow(1.0*constants[0], 0.618)+0.00122423) if gt_func(constants[0], 0.0) else 0.0 + computed_constants[138] = 7.5 if gt_func(constants[1], 0.0) else 0.0 + computed_constants[162] = 1.23 if gt_func(constants[1], 0.0) else 1.0 + computed_constants[165] = 0.31*constants[0]/(constants[0]+0.00009) + computed_constants[166] = -8.0 if gt_func(constants[1], 0.0) else 0.0 + computed_constants[167] = -27.0 if gt_func(constants[1], 0.0) else 0.0 + computed_constants[203] = 1.2*constants[204] if gt_func(constants[1], 0.0) else constants[204] + computed_constants[206] = -14.0 if gt_func(constants[1], 0.0) else 0.0 + computed_constants[213] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*constants[0], 1.6951))+0.025641 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - variables[5] = states[1] - variables[142] = variables[3]*log((variables[4]+0.12*variables[7])/(variables[5]+0.12*variables[8])) - variables[121] = variables[123] if and_func(gt_func(voi, variables[124]), lt_func(voi, variables[124]+variables[125])) else variables[126] - variables[21] = variables[121] if geq_func(variables[122], 1.0) else states[15] - variables[143] = variables[144]*pow(states[18], 3.0)*states[17]*(variables[21]-variables[142]) - variables[145] = variables[146]*pow(states[18], 3.0)*(variables[21]-variables[142]) - variables[12] = variables[143]+variables[145] - variables[15] = 0.0000185*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)/variables[3])))*(variables[5]-variables[4]*exp(-1.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21] - variables[2] = variables[3]*log(variables[4]/variables[5]) - variables[16] = states[16]*variables[133]*(variables[21]-variables[2])*(1.0-variables[135]) - variables[14] = variables[20]*variables[24]*pow(1.0+pow(variables[23]/variables[7], 1.2), -1.0)*pow(1.0+pow(variables[22]/variables[5], 1.3), -1.0)*pow(1.0+exp(-(variables[21]-variables[2]+110.0)/20.0), -1.0) - variables[50] = 1.0+variables[10]/variables[48]*(1.0+exp(variables[49]*variables[21]/variables[3]))+variables[4]/variables[51]*(1.0+variables[4]/variables[52]*(1.0+variables[4]/variables[47])) - variables[27] = variables[10]/variables[48]*exp(variables[49]*variables[21]/variables[3])/variables[50] - variables[42] = 1.0+states[0]/variables[40]*(1.0+exp(-variables[41]*variables[21]/variables[3])+variables[5]/variables[46])+variables[5]/variables[43]*(1.0+variables[5]/variables[44]*(1.0+variables[5]/variables[39])) - variables[29] = states[0]/variables[40]*exp(-variables[41]*variables[21]/variables[3])/variables[42] - variables[36] = variables[5]/(variables[39]+variables[5]) - variables[37] = exp(variables[45]*variables[21]/(2.0*variables[3])) - variables[33] = exp(-variables[45]*variables[21]/(2.0*variables[3])) - variables[38] = variables[5]/variables[43]*variables[5]/variables[44]*(1.0+variables[5]/variables[39])*exp(variables[45]*variables[21]/(2.0*variables[3]))/variables[42] - variables[26] = variables[37]*variables[36]*(variables[38]+variables[29])+variables[33]*variables[29]*(variables[35]+variables[37]) - variables[34] = variables[4]/variables[51]*variables[4]/variables[52]*(1.0+variables[4]/variables[47])*exp(-variables[45]*variables[21]/(2.0*variables[3]))/variables[50] - variables[28] = variables[33]*variables[35]*(variables[34]+variables[27])+variables[27]*variables[37]*(variables[36]+variables[33]) - variables[31] = variables[34]*variables[35]*(variables[38]+variables[29])+variables[38]*variables[27]*(variables[35]+variables[37]) - variables[32] = variables[38]*variables[36]*(variables[34]+variables[27])+variables[29]*variables[34]*(variables[36]+variables[33]) - variables[13] = (1.0-variables[25])*variables[30]*(variables[26]*variables[27]-variables[28]*variables[29])/(variables[28]+variables[26]+variables[32]+variables[31]) - rates[1] = (1.0-variables[11])*-1.0*(variables[12]+variables[16]+variables[15]+3.0*variables[14]+3.0*variables[13])/(1.0*(variables[18]+variables[19])*variables[17]) - variables[56] = variables[57]-(variables[57]-variables[58])/(1.0+pow(variables[59]/states[2], variables[60])) - variables[63] = variables[64]*variables[56] - variables[61] = variables[62]/variables[56] - rates[4] = variables[65]*states[5]-variables[63]*states[0]*states[4]-(variables[61]*pow(states[0], 2.0)*states[4]-variables[66]*states[3]) - rates[3] = variables[61]*pow(states[0], 2.0)*states[4]-variables[66]*states[3]-(variables[63]*states[0]*states[3]-variables[65]*states[6]) - rates[6] = variables[63]*states[0]*states[3]-variables[65]*states[6]-(variables[66]*states[6]-variables[61]*pow(states[0], 2.0)*states[5]) - rates[5] = variables[66]*states[6]-variables[61]*pow(states[0], 2.0)*states[5]-(variables[65]*states[5]-variables[63]*states[0]*states[4]) - variables[78] = variables[79]*states[7]*(1.0-states[9])-variables[80]*states[9] - rates[9] = variables[78] - variables[81] = variables[82]*states[7]*(1.0-(states[10]+states[11]))-variables[83]*states[10] - rates[10] = variables[81] - variables[84] = variables[85]*variables[86]*(1.0-(states[10]+states[11]))-variables[87]*states[11] - rates[11] = variables[84] - variables[88] = variables[89]*states[7]*(1.0-states[12])-variables[90]*states[12] - rates[12] = variables[88] - variables[91] = variables[89]*states[0]*(1.0-states[13])-variables[90]*states[13] - rates[13] = variables[91] - variables[92] = variables[93]*states[2]*(1.0-states[14])-variables[94]*states[14] - rates[14] = variables[92] - variables[71] = (states[0]-states[7])/variables[72] - variables[73] = variables[69]/(1.0+exp((-states[7]+variables[74])/variables[75])) - rates[7] = 1.0*(variables[71]*variables[19]-variables[73]*variables[99])/variables[18]-(variables[97]*variables[88]+variables[95]*variables[78]+variables[96]*variables[81]) - variables[53] = variables[54]*states[3]*(states[2]-states[0]) - variables[101] = 2.0*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)*2.0/variables[3])))*(states[0]-variables[10]*exp(-2.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21] - variables[102] = 2.0*variables[184]*variables[21]/(variables[3]*(1.0-exp(-1.0*variables[21]*2.0/variables[3])))*(states[0]-variables[10]*exp(-2.0*variables[21]/variables[3]))*states[25]*states[24] - rates[0] = variables[53]*variables[100]/variables[19]-((variables[101]+variables[102]-2.0*variables[13])/(2.0*variables[17]*variables[19])+variables[71]+variables[97]*variables[91]) - variables[76] = (states[8]-states[2])/variables[77] - rates[8] = variables[73]-variables[76]*variables[100]/variables[99] - rates[2] = variables[76]-(variables[53]+variables[98]*variables[92]) - variables[136] = states[16]*variables[134]*(variables[21]-variables[6])*(1.0-variables[135]) - variables[111] = variables[16]+variables[136] - variables[112] = variables[157]*states[20]*states[19]*(variables[21]-variables[6]) - variables[113] = variables[211]*variables[212]*(variables[21]-variables[6])*(1.0+exp((variables[21]+20.0)/20.0))*states[32] if gt_func(variables[0], 0.0) else 0.0 - variables[164] = 0.000365*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)/variables[3])))*(variables[8]-variables[7]*exp(-1.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21] - variables[114] = (variables[101]+variables[164]+variables[15])*(1.0-variables[165])*1.0*variables[162] - variables[115] = variables[190]*(variables[21]-variables[6])*states[27]*states[26] - variables[205] = variables[3]*log((variables[7]+0.12*variables[4])/(variables[8]+0.12*variables[5])) - variables[116] = variables[203]*(variables[21]-variables[205])*pow(states[31], 2.0) - variables[117] = variables[195]*(variables[21]-variables[6])*(0.9*states[29]+0.1*states[30])*states[28] - variables[110] = variables[111]+variables[117]+variables[116]+variables[115]+variables[14]+variables[13]+variables[12]+variables[114]+variables[102]+variables[113]+variables[112] - rates[15] = -variables[110]/variables[118] - variables[140] = 0.01329+0.99921/(1.0+exp((variables[21]+97.134-variables[137]-variables[138]-variables[141])/8.1752)) if lt_func(variables[21], -(80.0-variables[137]-variables[138]-variables[141])) else 0.0002501*exp(-(variables[21]-variables[137]-variables[138]-variables[141])/12.861) - variables[139] = 1.0/(0.36*(variables[21]+148.8-variables[137]-variables[138])/(exp(0.066*(variables[21]+148.8-variables[137]-variables[138]))-1.0)+0.1*(variables[21]+87.3-variables[137]-variables[138])/(1.0-exp(-0.2*(variables[21]+87.3-variables[137]-variables[138]))))-0.054 - rates[16] = (variables[140]-states[16])/variables[139] - variables[147] = 1.0/(1.0+exp(-(variables[21]+42.0504)/8.3106)) - variables[148] = variables[21]+41.0 - variables[149] = 2000.0 if lt_func(fabs(variables[148]), variables[150]) else 200.0*variables[148]/(1.0-exp(-0.1*variables[148])) - variables[151] = 8000.0*exp(-0.056*(variables[21]+66.0)) - variables[152] = 1.0/(variables[149]+variables[151]) - rates[18] = (variables[147]-states[18])/variables[152] - variables[153] = 1.0/(1.0+exp((variables[21]+69.804)/4.4565)) - variables[154] = 20.0*exp(-0.125*(variables[21]+75.0)) - variables[155] = 2000.0/(320.0*exp(-0.1*(variables[21]+75.0))+1.0) - variables[156] = 1.0/(variables[154]+variables[155]) - rates[17] = (variables[153]-states[17])/variables[156] - variables[158] = 1.0/(1.0+exp((variables[21]+6.0)/-8.6)) - variables[159] = 0.009/(1.0+exp((variables[21]+5.0)/12.0))+0.0005 - rates[20] = (variables[158]-states[20])/variables[159] - variables[160] = 1.0/(1.0+exp((variables[21]+7.5)/10.0)) - variables[161] = 0.59/(1.0+exp((variables[21]+60.0)/10.0))+3.05 - rates[19] = (variables[160]-states[19])/variables[161] - variables[168] = 1.0/(1.0+exp(-(variables[21]-variables[169]-variables[166])/(variables[170]*(1.0+variables[167]/100.0)))) - variables[174] = -41.80001 if eq_func(variables[21], -41.8) else 0.0 if eq_func(variables[21], 0.0) else -6.80001 if eq_func(variables[21], -6.8) else variables[21] - variables[172] = -0.02839*(variables[174]+41.8)/(exp(-(variables[174]+41.8)/2.5)-1.0)-0.0849*(variables[174]+6.8)/(exp(-(variables[174]+6.8)/4.8)-1.0) - variables[175] = -1.80001 if eq_func(variables[21], -1.8) else variables[21] - variables[173] = 0.01143*(variables[175]+1.8)/(exp((variables[175]+1.8)/2.5)-1.0) - variables[171] = 0.001/(variables[172]+variables[173]) - rates[23] = (variables[168]-states[23])/variables[171] - variables[176] = 1.0/(1.0+exp((variables[21]+37.4+variables[177])/(5.3+variables[178]))) - variables[179] = 0.001*(44.3+230.0*exp(-pow((variables[21]+36.0)/10.0, 2.0))) - rates[22] = (variables[176]-states[22])/variables[179] - variables[180] = variables[181]/(variables[181]+states[0]) - variables[182] = 0.001*variables[180]/variables[183] - rates[21] = (variables[180]-states[21])/variables[182] - variables[185] = 1.0/(1.0+exp(-(variables[21]+38.3)/5.5)) - variables[186] = 0.001/(1.068*exp((variables[21]+38.3)/30.0)+1.068*exp(-(variables[21]+38.3)/30.0)) - rates[25] = (variables[185]-states[25])/variables[186] - variables[187] = 1.0/(1.0+exp((variables[21]+58.7)/3.8)) - variables[188] = 1.0/(16.67*exp(-(variables[21]+75.0)/83.3)+16.67*exp((variables[21]+75.0)/15.38))+variables[189] - rates[24] = (variables[187]-states[24])/variables[188] - variables[191] = 1.0/(1.0+exp((variables[21]+49.0)/13.0)) - variables[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(variables[21]+44.0))+0.065*exp(0.1*(variables[21]+45.93)))+10.1) - rates[27] = (variables[191]-states[27])/variables[192] - variables[193] = 1.0/(1.0+exp(-(variables[21]-19.3)/15.0)) - variables[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(variables[21]+30.61))+0.369*exp(-0.12*(variables[21]+23.84)))+2.98) - rates[26] = (variables[193]-states[26])/variables[194] - variables[198] = 1.0/(1.0+exp(-(variables[21]+10.0144)/7.6607)) - variables[199] = 0.84655354/(4.2*exp(variables[21]/17.0)+0.15*exp(-variables[21]/21.6)) - rates[30] = (variables[198]-states[30])/variables[199] - variables[200] = 1.0/(30.0*exp(variables[21]/10.0)+exp(-variables[21]/12.0)) - rates[29] = (variables[198]-states[29])/variables[200] - variables[202] = 1.0/(1.0+exp((variables[21]+28.6)/17.1)) - variables[201] = 1.0/(100.0*exp(-variables[21]/54.645)+656.0*exp(variables[21]/106.157)) - rates[28] = (variables[202]-states[28])/variables[201] - variables[207] = sqrt(1.0/(1.0+exp(-(variables[21]+0.6383-variables[206])/10.7071))) - variables[209] = 28.0/(1.0+exp(-(variables[21]-40.0-variables[206])/3.0)) - variables[210] = 1.0*exp(-(variables[21]-variables[206]-5.0)/25.0) - variables[208] = 1.0/(variables[209]+variables[210]) - rates[31] = (variables[207]-states[31])/variables[208] - variables[214] = 10.0*exp(0.0133*(variables[21]+40.0)) - variables[215] = variables[213]/(variables[213]+variables[214]) - variables[216] = 1.0/(variables[213]+variables[214]) - rates[32] = (variables[215]-states[32])/variables[216] + algebraic[5] = states[1] + algebraic[142] = computed_constants[3]*log((constants[4]+0.12*constants[7])/(algebraic[5]+0.12*constants[8])) + algebraic[121] = constants[123] if and_func(gt_func(voi, constants[124]), lt_func(voi, constants[124]+constants[125])) else constants[126] + algebraic[21] = algebraic[121] if geq_func(constants[122], 1.0) else states[15] + algebraic[143] = constants[144]*pow(states[18], 3.0)*states[17]*(algebraic[21]-algebraic[142]) + algebraic[145] = constants[146]*pow(states[18], 3.0)*(algebraic[21]-algebraic[142]) + algebraic[12] = algebraic[143]+algebraic[145] + algebraic[15] = 0.0000185*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computed_constants[3])))*(algebraic[5]-constants[4]*exp(-1.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] + algebraic[2] = computed_constants[3]*log(constants[4]/algebraic[5]) + algebraic[16] = states[16]*computed_constants[133]*(algebraic[21]-algebraic[2])*(1.0-constants[135]) + algebraic[14] = computed_constants[20]*constants[24]*pow(1.0+pow(constants[23]/constants[7], 1.2), -1.0)*pow(1.0+pow(constants[22]/algebraic[5], 1.3), -1.0)*pow(1.0+exp(-(algebraic[21]-algebraic[2]+110.0)/20.0), -1.0) + algebraic[50] = 1.0+constants[10]/constants[48]*(1.0+exp(constants[49]*algebraic[21]/computed_constants[3]))+constants[4]/constants[51]*(1.0+constants[4]/constants[52]*(1.0+constants[4]/constants[47])) + algebraic[27] = constants[10]/constants[48]*exp(constants[49]*algebraic[21]/computed_constants[3])/algebraic[50] + algebraic[42] = 1.0+states[0]/constants[40]*(1.0+exp(-constants[41]*algebraic[21]/computed_constants[3])+algebraic[5]/constants[46])+algebraic[5]/constants[43]*(1.0+algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])) + algebraic[29] = states[0]/constants[40]*exp(-constants[41]*algebraic[21]/computed_constants[3])/algebraic[42] + algebraic[36] = algebraic[5]/(constants[39]+algebraic[5]) + algebraic[37] = exp(constants[45]*algebraic[21]/(2.0*computed_constants[3])) + algebraic[33] = exp(-constants[45]*algebraic[21]/(2.0*computed_constants[3])) + algebraic[38] = algebraic[5]/constants[43]*algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])*exp(constants[45]*algebraic[21]/(2.0*computed_constants[3]))/algebraic[42] + algebraic[26] = algebraic[37]*algebraic[36]*(algebraic[38]+algebraic[29])+algebraic[33]*algebraic[29]*(computed_constants[35]+algebraic[37]) + algebraic[34] = constants[4]/constants[51]*constants[4]/constants[52]*(1.0+constants[4]/constants[47])*exp(-constants[45]*algebraic[21]/(2.0*computed_constants[3]))/algebraic[50] + algebraic[28] = algebraic[33]*computed_constants[35]*(algebraic[34]+algebraic[27])+algebraic[27]*algebraic[37]*(algebraic[36]+algebraic[33]) + algebraic[31] = algebraic[34]*computed_constants[35]*(algebraic[38]+algebraic[29])+algebraic[38]*algebraic[27]*(computed_constants[35]+algebraic[37]) + algebraic[32] = algebraic[38]*algebraic[36]*(algebraic[34]+algebraic[27])+algebraic[29]*algebraic[34]*(algebraic[36]+algebraic[33]) + algebraic[13] = (1.0-constants[25])*constants[30]*(algebraic[26]*algebraic[27]-algebraic[28]*algebraic[29])/(algebraic[28]+algebraic[26]+algebraic[32]+algebraic[31]) + rates[1] = (1.0-constants[11])*-1.0*(algebraic[12]+algebraic[16]+algebraic[15]+3.0*algebraic[14]+3.0*algebraic[13])/(1.0*(computed_constants[18]+computed_constants[19])*constants[17]) + algebraic[56] = constants[57]-(constants[57]-constants[58])/(1.0+pow(constants[59]/states[2], constants[60])) + algebraic[63] = constants[64]*algebraic[56] + algebraic[61] = constants[62]/algebraic[56] + rates[4] = constants[65]*states[5]-algebraic[63]*states[0]*states[4]-(algebraic[61]*pow(states[0], 2.0)*states[4]-constants[66]*states[3]) + rates[3] = algebraic[61]*pow(states[0], 2.0)*states[4]-constants[66]*states[3]-(algebraic[63]*states[0]*states[3]-constants[65]*states[6]) + rates[6] = algebraic[63]*states[0]*states[3]-constants[65]*states[6]-(constants[66]*states[6]-algebraic[61]*pow(states[0], 2.0)*states[5]) + rates[5] = constants[66]*states[6]-algebraic[61]*pow(states[0], 2.0)*states[5]-(constants[65]*states[5]-algebraic[63]*states[0]*states[4]) + algebraic[78] = constants[79]*states[7]*(1.0-states[9])-constants[80]*states[9] + rates[9] = algebraic[78] + algebraic[81] = constants[82]*states[7]*(1.0-(states[10]+states[11]))-constants[83]*states[10] + rates[10] = algebraic[81] + algebraic[84] = constants[85]*constants[86]*(1.0-(states[10]+states[11]))-constants[87]*states[11] + rates[11] = algebraic[84] + algebraic[88] = constants[89]*states[7]*(1.0-states[12])-constants[90]*states[12] + rates[12] = algebraic[88] + algebraic[91] = constants[89]*states[0]*(1.0-states[13])-constants[90]*states[13] + rates[13] = algebraic[91] + algebraic[92] = constants[93]*states[2]*(1.0-states[14])-constants[94]*states[14] + rates[14] = algebraic[92] + algebraic[71] = (states[0]-states[7])/constants[72] + algebraic[73] = computed_constants[69]/(1.0+exp((-states[7]+constants[74])/constants[75])) + rates[7] = 1.0*(algebraic[71]*computed_constants[19]-algebraic[73]*computed_constants[99])/computed_constants[18]-(constants[97]*algebraic[88]+constants[95]*algebraic[78]+constants[96]*algebraic[81]) + algebraic[53] = constants[54]*states[3]*(states[2]-states[0]) + algebraic[101] = 2.0*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)*2.0/computed_constants[3])))*(states[0]-constants[10]*exp(-2.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] + algebraic[102] = 2.0*constants[184]*algebraic[21]/(computed_constants[3]*(1.0-exp(-1.0*algebraic[21]*2.0/computed_constants[3])))*(states[0]-constants[10]*exp(-2.0*algebraic[21]/computed_constants[3]))*states[25]*states[24] + rates[0] = algebraic[53]*computed_constants[100]/computed_constants[19]-((algebraic[101]+algebraic[102]-2.0*algebraic[13])/(2.0*constants[17]*computed_constants[19])+algebraic[71]+constants[97]*algebraic[91]) + algebraic[76] = (states[8]-states[2])/constants[77] + rates[8] = algebraic[73]-algebraic[76]*computed_constants[100]/computed_constants[99] + rates[2] = algebraic[76]-(algebraic[53]+constants[98]*algebraic[92]) + algebraic[136] = states[16]*computed_constants[134]*(algebraic[21]-computed_constants[6])*(1.0-constants[135]) + algebraic[111] = algebraic[16]+algebraic[136] + algebraic[112] = constants[157]*states[20]*states[19]*(algebraic[21]-computed_constants[6]) + algebraic[113] = constants[211]*constants[212]*(algebraic[21]-computed_constants[6])*(1.0+exp((algebraic[21]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 + algebraic[164] = 0.000365*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computed_constants[3])))*(constants[8]-constants[7]*exp(-1.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] + algebraic[114] = (algebraic[101]+algebraic[164]+algebraic[15])*(1.0-computed_constants[165])*1.0*computed_constants[162] + algebraic[115] = constants[190]*(algebraic[21]-computed_constants[6])*states[27]*states[26] + algebraic[205] = computed_constants[3]*log((constants[7]+0.12*constants[4])/(constants[8]+0.12*algebraic[5])) + algebraic[116] = computed_constants[203]*(algebraic[21]-algebraic[205])*pow(states[31], 2.0) + algebraic[117] = constants[195]*(algebraic[21]-computed_constants[6])*(0.9*states[29]+0.1*states[30])*states[28] + algebraic[110] = algebraic[111]+algebraic[117]+algebraic[116]+algebraic[115]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[114]+algebraic[102]+algebraic[113]+algebraic[112] + rates[15] = -algebraic[110]/constants[118] + algebraic[140] = 0.01329+0.99921/(1.0+exp((algebraic[21]+97.134-computed_constants[137]-computed_constants[138]-constants[141])/8.1752)) if lt_func(algebraic[21], -(80.0-computed_constants[137]-computed_constants[138]-constants[141])) else 0.0002501*exp(-(algebraic[21]-computed_constants[137]-computed_constants[138]-constants[141])/12.861) + algebraic[139] = 1.0/(0.36*(algebraic[21]+148.8-computed_constants[137]-computed_constants[138])/(exp(0.066*(algebraic[21]+148.8-computed_constants[137]-computed_constants[138]))-1.0)+0.1*(algebraic[21]+87.3-computed_constants[137]-computed_constants[138])/(1.0-exp(-0.2*(algebraic[21]+87.3-computed_constants[137]-computed_constants[138]))))-0.054 + rates[16] = (algebraic[140]-states[16])/algebraic[139] + algebraic[147] = 1.0/(1.0+exp(-(algebraic[21]+42.0504)/8.3106)) + algebraic[148] = algebraic[21]+41.0 + algebraic[149] = 2000.0 if lt_func(fabs(algebraic[148]), constants[150]) else 200.0*algebraic[148]/(1.0-exp(-0.1*algebraic[148])) + algebraic[151] = 8000.0*exp(-0.056*(algebraic[21]+66.0)) + algebraic[152] = 1.0/(algebraic[149]+algebraic[151]) + rates[18] = (algebraic[147]-states[18])/algebraic[152] + algebraic[153] = 1.0/(1.0+exp((algebraic[21]+69.804)/4.4565)) + algebraic[154] = 20.0*exp(-0.125*(algebraic[21]+75.0)) + algebraic[155] = 2000.0/(320.0*exp(-0.1*(algebraic[21]+75.0))+1.0) + algebraic[156] = 1.0/(algebraic[154]+algebraic[155]) + rates[17] = (algebraic[153]-states[17])/algebraic[156] + algebraic[158] = 1.0/(1.0+exp((algebraic[21]+6.0)/-8.6)) + algebraic[159] = 0.009/(1.0+exp((algebraic[21]+5.0)/12.0))+0.0005 + rates[20] = (algebraic[158]-states[20])/algebraic[159] + algebraic[160] = 1.0/(1.0+exp((algebraic[21]+7.5)/10.0)) + algebraic[161] = 0.59/(1.0+exp((algebraic[21]+60.0)/10.0))+3.05 + rates[19] = (algebraic[160]-states[19])/algebraic[161] + algebraic[168] = 1.0/(1.0+exp(-(algebraic[21]-constants[169]-computed_constants[166])/(constants[170]*(1.0+computed_constants[167]/100.0)))) + algebraic[174] = -41.80001 if eq_func(algebraic[21], -41.8) else 0.0 if eq_func(algebraic[21], 0.0) else -6.80001 if eq_func(algebraic[21], -6.8) else algebraic[21] + algebraic[172] = -0.02839*(algebraic[174]+41.8)/(exp(-(algebraic[174]+41.8)/2.5)-1.0)-0.0849*(algebraic[174]+6.8)/(exp(-(algebraic[174]+6.8)/4.8)-1.0) + algebraic[175] = -1.80001 if eq_func(algebraic[21], -1.8) else algebraic[21] + algebraic[173] = 0.01143*(algebraic[175]+1.8)/(exp((algebraic[175]+1.8)/2.5)-1.0) + algebraic[171] = 0.001/(algebraic[172]+algebraic[173]) + rates[23] = (algebraic[168]-states[23])/algebraic[171] + algebraic[176] = 1.0/(1.0+exp((algebraic[21]+37.4+constants[177])/(5.3+constants[178]))) + algebraic[179] = 0.001*(44.3+230.0*exp(-pow((algebraic[21]+36.0)/10.0, 2.0))) + rates[22] = (algebraic[176]-states[22])/algebraic[179] + algebraic[180] = constants[181]/(constants[181]+states[0]) + algebraic[182] = 0.001*algebraic[180]/constants[183] + rates[21] = (algebraic[180]-states[21])/algebraic[182] + algebraic[185] = 1.0/(1.0+exp(-(algebraic[21]+38.3)/5.5)) + algebraic[186] = 0.001/(1.068*exp((algebraic[21]+38.3)/30.0)+1.068*exp(-(algebraic[21]+38.3)/30.0)) + rates[25] = (algebraic[185]-states[25])/algebraic[186] + algebraic[187] = 1.0/(1.0+exp((algebraic[21]+58.7)/3.8)) + algebraic[188] = 1.0/(16.67*exp(-(algebraic[21]+75.0)/83.3)+16.67*exp((algebraic[21]+75.0)/15.38))+constants[189] + rates[24] = (algebraic[187]-states[24])/algebraic[188] + algebraic[191] = 1.0/(1.0+exp((algebraic[21]+49.0)/13.0)) + algebraic[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[21]+44.0))+0.065*exp(0.1*(algebraic[21]+45.93)))+10.1) + rates[27] = (algebraic[191]-states[27])/algebraic[192] + algebraic[193] = 1.0/(1.0+exp(-(algebraic[21]-19.3)/15.0)) + algebraic[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[21]+30.61))+0.369*exp(-0.12*(algebraic[21]+23.84)))+2.98) + rates[26] = (algebraic[193]-states[26])/algebraic[194] + algebraic[198] = 1.0/(1.0+exp(-(algebraic[21]+10.0144)/7.6607)) + algebraic[199] = 0.84655354/(4.2*exp(algebraic[21]/17.0)+0.15*exp(-algebraic[21]/21.6)) + rates[30] = (algebraic[198]-states[30])/algebraic[199] + algebraic[200] = 1.0/(30.0*exp(algebraic[21]/10.0)+exp(-algebraic[21]/12.0)) + rates[29] = (algebraic[198]-states[29])/algebraic[200] + algebraic[202] = 1.0/(1.0+exp((algebraic[21]+28.6)/17.1)) + algebraic[201] = 1.0/(100.0*exp(-algebraic[21]/54.645)+656.0*exp(algebraic[21]/106.157)) + rates[28] = (algebraic[202]-states[28])/algebraic[201] + algebraic[207] = sqrt(1.0/(1.0+exp(-(algebraic[21]+0.6383-computed_constants[206])/10.7071))) + algebraic[209] = 28.0/(1.0+exp(-(algebraic[21]-40.0-computed_constants[206])/3.0)) + algebraic[210] = 1.0*exp(-(algebraic[21]-computed_constants[206]-5.0)/25.0) + algebraic[208] = 1.0/(algebraic[209]+algebraic[210]) + rates[31] = (algebraic[207]-states[31])/algebraic[208] + algebraic[214] = 10.0*exp(0.0133*(algebraic[21]+40.0)) + algebraic[215] = computed_constants[213]/(computed_constants[213]+algebraic[214]) + algebraic[216] = 1.0/(computed_constants[213]+algebraic[214]) + rates[32] = (algebraic[215]-states[32])/algebraic[216] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[5] = states[1] - variables[2] = variables[3]*log(variables[4]/variables[5]) - variables[9] = 0.5*variables[3]*log(variables[10]/states[0]) - variables[21] = variables[121] if geq_func(variables[122], 1.0) else states[15] - variables[14] = variables[20]*variables[24]*pow(1.0+pow(variables[23]/variables[7], 1.2), -1.0)*pow(1.0+pow(variables[22]/variables[5], 1.3), -1.0)*pow(1.0+exp(-(variables[21]-variables[2]+110.0)/20.0), -1.0) - variables[50] = 1.0+variables[10]/variables[48]*(1.0+exp(variables[49]*variables[21]/variables[3]))+variables[4]/variables[51]*(1.0+variables[4]/variables[52]*(1.0+variables[4]/variables[47])) - variables[27] = variables[10]/variables[48]*exp(variables[49]*variables[21]/variables[3])/variables[50] - variables[42] = 1.0+states[0]/variables[40]*(1.0+exp(-variables[41]*variables[21]/variables[3])+variables[5]/variables[46])+variables[5]/variables[43]*(1.0+variables[5]/variables[44]*(1.0+variables[5]/variables[39])) - variables[29] = states[0]/variables[40]*exp(-variables[41]*variables[21]/variables[3])/variables[42] - variables[36] = variables[5]/(variables[39]+variables[5]) - variables[37] = exp(variables[45]*variables[21]/(2.0*variables[3])) - variables[33] = exp(-variables[45]*variables[21]/(2.0*variables[3])) - variables[38] = variables[5]/variables[43]*variables[5]/variables[44]*(1.0+variables[5]/variables[39])*exp(variables[45]*variables[21]/(2.0*variables[3]))/variables[42] - variables[26] = variables[37]*variables[36]*(variables[38]+variables[29])+variables[33]*variables[29]*(variables[35]+variables[37]) - variables[34] = variables[4]/variables[51]*variables[4]/variables[52]*(1.0+variables[4]/variables[47])*exp(-variables[45]*variables[21]/(2.0*variables[3]))/variables[50] - variables[28] = variables[33]*variables[35]*(variables[34]+variables[27])+variables[27]*variables[37]*(variables[36]+variables[33]) - variables[31] = variables[34]*variables[35]*(variables[38]+variables[29])+variables[38]*variables[27]*(variables[35]+variables[37]) - variables[32] = variables[38]*variables[36]*(variables[34]+variables[27])+variables[29]*variables[34]*(variables[36]+variables[33]) - variables[13] = (1.0-variables[25])*variables[30]*(variables[26]*variables[27]-variables[28]*variables[29])/(variables[28]+variables[26]+variables[32]+variables[31]) - variables[53] = variables[54]*states[3]*(states[2]-states[0]) - variables[55] = states[2]-states[0] - variables[56] = variables[57]-(variables[57]-variables[58])/(1.0+pow(variables[59]/states[2], variables[60])) - variables[61] = variables[62]/variables[56] - variables[63] = variables[64]*variables[56] - variables[67] = states[4]+states[3]+states[6]+states[5] - variables[71] = (states[0]-states[7])/variables[72] - variables[73] = variables[69]/(1.0+exp((-states[7]+variables[74])/variables[75])) - variables[76] = (states[8]-states[2])/variables[77] - variables[78] = variables[79]*states[7]*(1.0-states[9])-variables[80]*states[9] - variables[81] = variables[82]*states[7]*(1.0-(states[10]+states[11]))-variables[83]*states[10] - variables[84] = variables[85]*variables[86]*(1.0-(states[10]+states[11]))-variables[87]*states[11] - variables[88] = variables[89]*states[7]*(1.0-states[12])-variables[90]*states[12] - variables[91] = variables[89]*states[0]*(1.0-states[13])-variables[90]*states[13] - variables[92] = variables[93]*states[2]*(1.0-states[14])-variables[94]*states[14] - variables[16] = states[16]*variables[133]*(variables[21]-variables[2])*(1.0-variables[135]) - variables[136] = states[16]*variables[134]*(variables[21]-variables[6])*(1.0-variables[135]) - variables[111] = variables[16]+variables[136] - variables[112] = variables[157]*states[20]*states[19]*(variables[21]-variables[6]) - variables[113] = variables[211]*variables[212]*(variables[21]-variables[6])*(1.0+exp((variables[21]+20.0)/20.0))*states[32] if gt_func(variables[0], 0.0) else 0.0 - variables[102] = 2.0*variables[184]*variables[21]/(variables[3]*(1.0-exp(-1.0*variables[21]*2.0/variables[3])))*(states[0]-variables[10]*exp(-2.0*variables[21]/variables[3]))*states[25]*states[24] - variables[101] = 2.0*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)*2.0/variables[3])))*(states[0]-variables[10]*exp(-2.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21] - variables[15] = 0.0000185*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)/variables[3])))*(variables[5]-variables[4]*exp(-1.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21] - variables[164] = 0.000365*variables[163]*(variables[21]-0.0)/(variables[3]*(1.0-exp(-1.0*(variables[21]-0.0)/variables[3])))*(variables[8]-variables[7]*exp(-1.0*(variables[21]-0.0)/variables[3]))*states[23]*states[22]*states[21] - variables[114] = (variables[101]+variables[164]+variables[15])*(1.0-variables[165])*1.0*variables[162] - variables[142] = variables[3]*log((variables[4]+0.12*variables[7])/(variables[5]+0.12*variables[8])) - variables[143] = variables[144]*pow(states[18], 3.0)*states[17]*(variables[21]-variables[142]) - variables[145] = variables[146]*pow(states[18], 3.0)*(variables[21]-variables[142]) - variables[12] = variables[143]+variables[145] - variables[115] = variables[190]*(variables[21]-variables[6])*states[27]*states[26] - variables[205] = variables[3]*log((variables[7]+0.12*variables[4])/(variables[8]+0.12*variables[5])) - variables[116] = variables[203]*(variables[21]-variables[205])*pow(states[31], 2.0) - variables[117] = variables[195]*(variables[21]-variables[6])*(0.9*states[29]+0.1*states[30])*states[28] - variables[110] = variables[111]+variables[117]+variables[116]+variables[115]+variables[14]+variables[13]+variables[12]+variables[114]+variables[102]+variables[113]+variables[112] - variables[139] = 1.0/(0.36*(variables[21]+148.8-variables[137]-variables[138])/(exp(0.066*(variables[21]+148.8-variables[137]-variables[138]))-1.0)+0.1*(variables[21]+87.3-variables[137]-variables[138])/(1.0-exp(-0.2*(variables[21]+87.3-variables[137]-variables[138]))))-0.054 - variables[140] = 0.01329+0.99921/(1.0+exp((variables[21]+97.134-variables[137]-variables[138]-variables[141])/8.1752)) if lt_func(variables[21], -(80.0-variables[137]-variables[138]-variables[141])) else 0.0002501*exp(-(variables[21]-variables[137]-variables[138]-variables[141])/12.861) - variables[147] = 1.0/(1.0+exp(-(variables[21]+42.0504)/8.3106)) - variables[148] = variables[21]+41.0 - variables[149] = 2000.0 if lt_func(fabs(variables[148]), variables[150]) else 200.0*variables[148]/(1.0-exp(-0.1*variables[148])) - variables[151] = 8000.0*exp(-0.056*(variables[21]+66.0)) - variables[152] = 1.0/(variables[149]+variables[151]) - variables[153] = 1.0/(1.0+exp((variables[21]+69.804)/4.4565)) - variables[154] = 20.0*exp(-0.125*(variables[21]+75.0)) - variables[155] = 2000.0/(320.0*exp(-0.1*(variables[21]+75.0))+1.0) - variables[156] = 1.0/(variables[154]+variables[155]) - variables[158] = 1.0/(1.0+exp((variables[21]+6.0)/-8.6)) - variables[159] = 0.009/(1.0+exp((variables[21]+5.0)/12.0))+0.0005 - variables[160] = 1.0/(1.0+exp((variables[21]+7.5)/10.0)) - variables[161] = 0.59/(1.0+exp((variables[21]+60.0)/10.0))+3.05 - variables[168] = 1.0/(1.0+exp(-(variables[21]-variables[169]-variables[166])/(variables[170]*(1.0+variables[167]/100.0)))) - variables[174] = -41.80001 if eq_func(variables[21], -41.8) else 0.0 if eq_func(variables[21], 0.0) else -6.80001 if eq_func(variables[21], -6.8) else variables[21] - variables[172] = -0.02839*(variables[174]+41.8)/(exp(-(variables[174]+41.8)/2.5)-1.0)-0.0849*(variables[174]+6.8)/(exp(-(variables[174]+6.8)/4.8)-1.0) - variables[175] = -1.80001 if eq_func(variables[21], -1.8) else variables[21] - variables[173] = 0.01143*(variables[175]+1.8)/(exp((variables[175]+1.8)/2.5)-1.0) - variables[171] = 0.001/(variables[172]+variables[173]) - variables[176] = 1.0/(1.0+exp((variables[21]+37.4+variables[177])/(5.3+variables[178]))) - variables[179] = 0.001*(44.3+230.0*exp(-pow((variables[21]+36.0)/10.0, 2.0))) - variables[180] = variables[181]/(variables[181]+states[0]) - variables[182] = 0.001*variables[180]/variables[183] - variables[185] = 1.0/(1.0+exp(-(variables[21]+38.3)/5.5)) - variables[186] = 0.001/(1.068*exp((variables[21]+38.3)/30.0)+1.068*exp(-(variables[21]+38.3)/30.0)) - variables[187] = 1.0/(1.0+exp((variables[21]+58.7)/3.8)) - variables[188] = 1.0/(16.67*exp(-(variables[21]+75.0)/83.3)+16.67*exp((variables[21]+75.0)/15.38))+variables[189] - variables[191] = 1.0/(1.0+exp((variables[21]+49.0)/13.0)) - variables[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(variables[21]+44.0))+0.065*exp(0.1*(variables[21]+45.93)))+10.1) - variables[193] = 1.0/(1.0+exp(-(variables[21]-19.3)/15.0)) - variables[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(variables[21]+30.61))+0.369*exp(-0.12*(variables[21]+23.84)))+2.98) - variables[196] = 1.0/(1.0+exp(-(variables[21]+23.2)/6.6))/(0.84655354/(37.2*exp(variables[21]/11.9)+0.96*exp(-variables[21]/18.5))) - variables[197] = 4.0*((37.2*exp(variables[21]/15.9)+0.96*exp(-variables[21]/22.5))/0.84655354-1.0/(1.0+exp(-(variables[21]+23.2)/10.6))/(0.84655354/(37.2*exp(variables[21]/15.9)+0.96*exp(-variables[21]/22.5)))) - variables[198] = 1.0/(1.0+exp(-(variables[21]+10.0144)/7.6607)) - variables[199] = 0.84655354/(4.2*exp(variables[21]/17.0)+0.15*exp(-variables[21]/21.6)) - variables[200] = 1.0/(30.0*exp(variables[21]/10.0)+exp(-variables[21]/12.0)) - variables[201] = 1.0/(100.0*exp(-variables[21]/54.645)+656.0*exp(variables[21]/106.157)) - variables[202] = 1.0/(1.0+exp((variables[21]+28.6)/17.1)) - variables[207] = sqrt(1.0/(1.0+exp(-(variables[21]+0.6383-variables[206])/10.7071))) - variables[209] = 28.0/(1.0+exp(-(variables[21]-40.0-variables[206])/3.0)) - variables[210] = 1.0*exp(-(variables[21]-variables[206]-5.0)/25.0) - variables[208] = 1.0/(variables[209]+variables[210]) - variables[214] = 10.0*exp(0.0133*(variables[21]+40.0)) - variables[215] = variables[213]/(variables[213]+variables[214]) - variables[216] = 1.0/(variables[213]+variables[214]) + algebraic[5] = states[1] + algebraic[2] = computed_constants[3]*log(constants[4]/algebraic[5]) + algebraic[9] = 0.5*computed_constants[3]*log(constants[10]/states[0]) + algebraic[21] = algebraic[121] if geq_func(constants[122], 1.0) else states[15] + algebraic[14] = computed_constants[20]*constants[24]*pow(1.0+pow(constants[23]/constants[7], 1.2), -1.0)*pow(1.0+pow(constants[22]/algebraic[5], 1.3), -1.0)*pow(1.0+exp(-(algebraic[21]-algebraic[2]+110.0)/20.0), -1.0) + algebraic[50] = 1.0+constants[10]/constants[48]*(1.0+exp(constants[49]*algebraic[21]/computed_constants[3]))+constants[4]/constants[51]*(1.0+constants[4]/constants[52]*(1.0+constants[4]/constants[47])) + algebraic[27] = constants[10]/constants[48]*exp(constants[49]*algebraic[21]/computed_constants[3])/algebraic[50] + algebraic[42] = 1.0+states[0]/constants[40]*(1.0+exp(-constants[41]*algebraic[21]/computed_constants[3])+algebraic[5]/constants[46])+algebraic[5]/constants[43]*(1.0+algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])) + algebraic[29] = states[0]/constants[40]*exp(-constants[41]*algebraic[21]/computed_constants[3])/algebraic[42] + algebraic[36] = algebraic[5]/(constants[39]+algebraic[5]) + algebraic[37] = exp(constants[45]*algebraic[21]/(2.0*computed_constants[3])) + algebraic[33] = exp(-constants[45]*algebraic[21]/(2.0*computed_constants[3])) + algebraic[38] = algebraic[5]/constants[43]*algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])*exp(constants[45]*algebraic[21]/(2.0*computed_constants[3]))/algebraic[42] + algebraic[26] = algebraic[37]*algebraic[36]*(algebraic[38]+algebraic[29])+algebraic[33]*algebraic[29]*(computed_constants[35]+algebraic[37]) + algebraic[34] = constants[4]/constants[51]*constants[4]/constants[52]*(1.0+constants[4]/constants[47])*exp(-constants[45]*algebraic[21]/(2.0*computed_constants[3]))/algebraic[50] + algebraic[28] = algebraic[33]*computed_constants[35]*(algebraic[34]+algebraic[27])+algebraic[27]*algebraic[37]*(algebraic[36]+algebraic[33]) + algebraic[31] = algebraic[34]*computed_constants[35]*(algebraic[38]+algebraic[29])+algebraic[38]*algebraic[27]*(computed_constants[35]+algebraic[37]) + algebraic[32] = algebraic[38]*algebraic[36]*(algebraic[34]+algebraic[27])+algebraic[29]*algebraic[34]*(algebraic[36]+algebraic[33]) + algebraic[13] = (1.0-constants[25])*constants[30]*(algebraic[26]*algebraic[27]-algebraic[28]*algebraic[29])/(algebraic[28]+algebraic[26]+algebraic[32]+algebraic[31]) + algebraic[53] = constants[54]*states[3]*(states[2]-states[0]) + algebraic[55] = states[2]-states[0] + algebraic[56] = constants[57]-(constants[57]-constants[58])/(1.0+pow(constants[59]/states[2], constants[60])) + algebraic[61] = constants[62]/algebraic[56] + algebraic[63] = constants[64]*algebraic[56] + algebraic[67] = states[4]+states[3]+states[6]+states[5] + algebraic[71] = (states[0]-states[7])/constants[72] + algebraic[73] = computed_constants[69]/(1.0+exp((-states[7]+constants[74])/constants[75])) + algebraic[76] = (states[8]-states[2])/constants[77] + algebraic[78] = constants[79]*states[7]*(1.0-states[9])-constants[80]*states[9] + algebraic[81] = constants[82]*states[7]*(1.0-(states[10]+states[11]))-constants[83]*states[10] + algebraic[84] = constants[85]*constants[86]*(1.0-(states[10]+states[11]))-constants[87]*states[11] + algebraic[88] = constants[89]*states[7]*(1.0-states[12])-constants[90]*states[12] + algebraic[91] = constants[89]*states[0]*(1.0-states[13])-constants[90]*states[13] + algebraic[92] = constants[93]*states[2]*(1.0-states[14])-constants[94]*states[14] + algebraic[16] = states[16]*computed_constants[133]*(algebraic[21]-algebraic[2])*(1.0-constants[135]) + algebraic[136] = states[16]*computed_constants[134]*(algebraic[21]-computed_constants[6])*(1.0-constants[135]) + algebraic[111] = algebraic[16]+algebraic[136] + algebraic[112] = constants[157]*states[20]*states[19]*(algebraic[21]-computed_constants[6]) + algebraic[113] = constants[211]*constants[212]*(algebraic[21]-computed_constants[6])*(1.0+exp((algebraic[21]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 + algebraic[102] = 2.0*constants[184]*algebraic[21]/(computed_constants[3]*(1.0-exp(-1.0*algebraic[21]*2.0/computed_constants[3])))*(states[0]-constants[10]*exp(-2.0*algebraic[21]/computed_constants[3]))*states[25]*states[24] + algebraic[101] = 2.0*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)*2.0/computed_constants[3])))*(states[0]-constants[10]*exp(-2.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] + algebraic[15] = 0.0000185*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computed_constants[3])))*(algebraic[5]-constants[4]*exp(-1.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] + algebraic[164] = 0.000365*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computed_constants[3])))*(constants[8]-constants[7]*exp(-1.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] + algebraic[114] = (algebraic[101]+algebraic[164]+algebraic[15])*(1.0-computed_constants[165])*1.0*computed_constants[162] + algebraic[142] = computed_constants[3]*log((constants[4]+0.12*constants[7])/(algebraic[5]+0.12*constants[8])) + algebraic[143] = constants[144]*pow(states[18], 3.0)*states[17]*(algebraic[21]-algebraic[142]) + algebraic[145] = constants[146]*pow(states[18], 3.0)*(algebraic[21]-algebraic[142]) + algebraic[12] = algebraic[143]+algebraic[145] + algebraic[115] = constants[190]*(algebraic[21]-computed_constants[6])*states[27]*states[26] + algebraic[205] = computed_constants[3]*log((constants[7]+0.12*constants[4])/(constants[8]+0.12*algebraic[5])) + algebraic[116] = computed_constants[203]*(algebraic[21]-algebraic[205])*pow(states[31], 2.0) + algebraic[117] = constants[195]*(algebraic[21]-computed_constants[6])*(0.9*states[29]+0.1*states[30])*states[28] + algebraic[110] = algebraic[111]+algebraic[117]+algebraic[116]+algebraic[115]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[114]+algebraic[102]+algebraic[113]+algebraic[112] + algebraic[139] = 1.0/(0.36*(algebraic[21]+148.8-computed_constants[137]-computed_constants[138])/(exp(0.066*(algebraic[21]+148.8-computed_constants[137]-computed_constants[138]))-1.0)+0.1*(algebraic[21]+87.3-computed_constants[137]-computed_constants[138])/(1.0-exp(-0.2*(algebraic[21]+87.3-computed_constants[137]-computed_constants[138]))))-0.054 + algebraic[140] = 0.01329+0.99921/(1.0+exp((algebraic[21]+97.134-computed_constants[137]-computed_constants[138]-constants[141])/8.1752)) if lt_func(algebraic[21], -(80.0-computed_constants[137]-computed_constants[138]-constants[141])) else 0.0002501*exp(-(algebraic[21]-computed_constants[137]-computed_constants[138]-constants[141])/12.861) + algebraic[147] = 1.0/(1.0+exp(-(algebraic[21]+42.0504)/8.3106)) + algebraic[148] = algebraic[21]+41.0 + algebraic[149] = 2000.0 if lt_func(fabs(algebraic[148]), constants[150]) else 200.0*algebraic[148]/(1.0-exp(-0.1*algebraic[148])) + algebraic[151] = 8000.0*exp(-0.056*(algebraic[21]+66.0)) + algebraic[152] = 1.0/(algebraic[149]+algebraic[151]) + algebraic[153] = 1.0/(1.0+exp((algebraic[21]+69.804)/4.4565)) + algebraic[154] = 20.0*exp(-0.125*(algebraic[21]+75.0)) + algebraic[155] = 2000.0/(320.0*exp(-0.1*(algebraic[21]+75.0))+1.0) + algebraic[156] = 1.0/(algebraic[154]+algebraic[155]) + algebraic[158] = 1.0/(1.0+exp((algebraic[21]+6.0)/-8.6)) + algebraic[159] = 0.009/(1.0+exp((algebraic[21]+5.0)/12.0))+0.0005 + algebraic[160] = 1.0/(1.0+exp((algebraic[21]+7.5)/10.0)) + algebraic[161] = 0.59/(1.0+exp((algebraic[21]+60.0)/10.0))+3.05 + algebraic[168] = 1.0/(1.0+exp(-(algebraic[21]-constants[169]-computed_constants[166])/(constants[170]*(1.0+computed_constants[167]/100.0)))) + algebraic[174] = -41.80001 if eq_func(algebraic[21], -41.8) else 0.0 if eq_func(algebraic[21], 0.0) else -6.80001 if eq_func(algebraic[21], -6.8) else algebraic[21] + algebraic[172] = -0.02839*(algebraic[174]+41.8)/(exp(-(algebraic[174]+41.8)/2.5)-1.0)-0.0849*(algebraic[174]+6.8)/(exp(-(algebraic[174]+6.8)/4.8)-1.0) + algebraic[175] = -1.80001 if eq_func(algebraic[21], -1.8) else algebraic[21] + algebraic[173] = 0.01143*(algebraic[175]+1.8)/(exp((algebraic[175]+1.8)/2.5)-1.0) + algebraic[171] = 0.001/(algebraic[172]+algebraic[173]) + algebraic[176] = 1.0/(1.0+exp((algebraic[21]+37.4+constants[177])/(5.3+constants[178]))) + algebraic[179] = 0.001*(44.3+230.0*exp(-pow((algebraic[21]+36.0)/10.0, 2.0))) + algebraic[180] = constants[181]/(constants[181]+states[0]) + algebraic[182] = 0.001*algebraic[180]/constants[183] + algebraic[185] = 1.0/(1.0+exp(-(algebraic[21]+38.3)/5.5)) + algebraic[186] = 0.001/(1.068*exp((algebraic[21]+38.3)/30.0)+1.068*exp(-(algebraic[21]+38.3)/30.0)) + algebraic[187] = 1.0/(1.0+exp((algebraic[21]+58.7)/3.8)) + algebraic[188] = 1.0/(16.67*exp(-(algebraic[21]+75.0)/83.3)+16.67*exp((algebraic[21]+75.0)/15.38))+constants[189] + algebraic[191] = 1.0/(1.0+exp((algebraic[21]+49.0)/13.0)) + algebraic[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[21]+44.0))+0.065*exp(0.1*(algebraic[21]+45.93)))+10.1) + algebraic[193] = 1.0/(1.0+exp(-(algebraic[21]-19.3)/15.0)) + algebraic[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[21]+30.61))+0.369*exp(-0.12*(algebraic[21]+23.84)))+2.98) + algebraic[196] = 1.0/(1.0+exp(-(algebraic[21]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraic[21]/11.9)+0.96*exp(-algebraic[21]/18.5))) + algebraic[197] = 4.0*((37.2*exp(algebraic[21]/15.9)+0.96*exp(-algebraic[21]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraic[21]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraic[21]/15.9)+0.96*exp(-algebraic[21]/22.5)))) + algebraic[198] = 1.0/(1.0+exp(-(algebraic[21]+10.0144)/7.6607)) + algebraic[199] = 0.84655354/(4.2*exp(algebraic[21]/17.0)+0.15*exp(-algebraic[21]/21.6)) + algebraic[200] = 1.0/(30.0*exp(algebraic[21]/10.0)+exp(-algebraic[21]/12.0)) + algebraic[201] = 1.0/(100.0*exp(-algebraic[21]/54.645)+656.0*exp(algebraic[21]/106.157)) + algebraic[202] = 1.0/(1.0+exp((algebraic[21]+28.6)/17.1)) + algebraic[207] = sqrt(1.0/(1.0+exp(-(algebraic[21]+0.6383-computed_constants[206])/10.7071))) + algebraic[209] = 28.0/(1.0+exp(-(algebraic[21]-40.0-computed_constants[206])/3.0)) + algebraic[210] = 1.0*exp(-(algebraic[21]-computed_constants[206]-5.0)/25.0) + algebraic[208] = 1.0/(algebraic[209]+algebraic[210]) + algebraic[214] = 10.0*exp(0.0133*(algebraic[21]+40.0)) + algebraic[215] = computed_constants[213]/(computed_constants[213]+algebraic[214]) + algebraic[216] = 1.0/(computed_constants[213]+algebraic[214]) diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index d2856f1c0..229024166 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -250,116 +250,116 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[1] = 0.0; - variables[2] = 1.0; - variables[3] = 1.0309347; - variables[5] = 2.0e-5; - variables[6] = 6.5e-5; - variables[22] = 8314.0; - variables[23] = 310.0; - variables[24] = 96845.0; - variables[26] = 5.8e-5; - variables[27] = 0.000189; - variables[28] = 5.8e-5; - variables[29] = 0.000189; - variables[30] = 5.81818e-5; - variables[31] = 0.0001888; - variables[34] = 2.52e-5; - variables[35] = 8.19e-5; - variables[36] = 2.52e-5; - variables[37] = 8.19e-5; - variables[38] = 2.523636e-5; - variables[39] = 8.1892e-5; - variables[42] = 1.32e-5; - variables[43] = 4.3e-5; - variables[44] = 1.323e-5; - variables[45] = 4.29e-5; - variables[46] = 1.3236e-5; - variables[47] = 4.2952e-5; - variables[50] = 2.7e-6; - variables[51] = 8.8e-6; - variables[52] = 2.8e-6; - variables[53] = 8.8e-6; - variables[54] = 2.7229e-6; - variables[55] = 8.83584e-6; - variables[56] = 8.0; - variables[57] = 0.5; - variables[58] = 2.0; - variables[59] = 140.0; - variables[60] = 0.0001; - variables[61] = 0.0001; - variables[63] = 0.0478; - variables[64] = 0.16; - variables[65] = 0.0478; - variables[66] = 0.16; - variables[67] = 0.04782545; - variables[68] = 0.1551936; - variables[69] = 5.4; - variables[70] = 0.621; - variables[71] = 5.64; - variables[73] = 0.0; - variables[74] = 0.0; - variables[75] = 0.0042; - variables[76] = 0.03339; - variables[77] = 0.0; - variables[78] = 0.0; - variables[79] = 140.0; - variables[82] = 0.0; - variables[83] = 1.2e-6; - variables[84] = 0.0; - variables[85] = 3.7e-7; - variables[86] = 0.0; - variables[87] = 1.204e-6; - variables[97] = 0.0058; - variables[98] = 0.0659; - variables[99] = 0.0082; - variables[100] = 0.0659; - variables[101] = 0.0057938; - variables[102] = 0.06588648; - variables[103] = 46.4; - variables[113] = 0.0043; - variables[114] = 0.0139; - variables[115] = 0.0021; - variables[116] = 0.00694; - variables[117] = 0.00427806; - variables[118] = 0.0138823; - variables[119] = 45.0; - variables[129] = 0.00491; - variables[130] = 0.03649; - variables[131] = 0.004905; - variables[132] = 0.0365; - variables[133] = 0.004905; - variables[134] = 0.036495; - variables[136] = 6.65e-5; - variables[137] = 0.0114; - variables[138] = 0.000266; - variables[139] = 0.0114; - variables[140] = 6.645504e-5; - variables[141] = 0.01138376; - variables[147] = 0.000797; - variables[148] = 0.016; - variables[149] = 0.000738; - variables[150] = 0.0208; - variables[151] = 0.00079704; - variables[152] = 0.016; - variables[161] = 0.000518; - variables[162] = 0.0104; - variables[163] = 0.000345; - variables[164] = 0.0104; - variables[165] = 0.0003445; - variables[166] = 0.0104; - variables[170] = 0.000548; - variables[171] = 0.0069; - variables[172] = 0.000437; - variables[173] = 0.0055; - variables[174] = 0.0005465; - variables[175] = 0.006875; - variables[177] = 0.000548; - variables[178] = 0.0069; - variables[179] = 0.000437; - variables[180] = 0.0055; - variables[181] = 0.0005465; - variables[182] = 0.006875; + constants[1] = 0.0; + constants[2] = 1.0; + constants[3] = 1.0309347; + constants[5] = 2.0e-5; + constants[6] = 6.5e-5; + constants[22] = 8314.0; + constants[23] = 310.0; + constants[24] = 96845.0; + constants[26] = 5.8e-5; + constants[27] = 0.000189; + constants[28] = 5.8e-5; + constants[29] = 0.000189; + constants[30] = 5.81818e-5; + constants[31] = 0.0001888; + constants[34] = 2.52e-5; + constants[35] = 8.19e-5; + constants[36] = 2.52e-5; + constants[37] = 8.19e-5; + constants[38] = 2.523636e-5; + constants[39] = 8.1892e-5; + constants[42] = 1.32e-5; + constants[43] = 4.3e-5; + constants[44] = 1.323e-5; + constants[45] = 4.29e-5; + constants[46] = 1.3236e-5; + constants[47] = 4.2952e-5; + constants[50] = 2.7e-6; + constants[51] = 8.8e-6; + constants[52] = 2.8e-6; + constants[53] = 8.8e-6; + constants[54] = 2.7229e-6; + constants[55] = 8.83584e-6; + constants[56] = 8.0; + constants[57] = 0.5; + constants[58] = 2.0; + constants[59] = 140.0; + constants[60] = 0.0001; + constants[61] = 0.0001; + constants[63] = 0.0478; + constants[64] = 0.16; + constants[65] = 0.0478; + constants[66] = 0.16; + constants[67] = 0.04782545; + constants[68] = 0.1551936; + constants[69] = 5.4; + constants[70] = 0.621; + constants[71] = 5.64; + constants[73] = 0.0; + constants[74] = 0.0; + constants[75] = 0.0042; + constants[76] = 0.03339; + constants[77] = 0.0; + constants[78] = 0.0; + constants[79] = 140.0; + constants[82] = 0.0; + constants[83] = 1.2e-6; + constants[84] = 0.0; + constants[85] = 3.7e-7; + constants[86] = 0.0; + constants[87] = 1.204e-6; + constants[97] = 0.0058; + constants[98] = 0.0659; + constants[99] = 0.0082; + constants[100] = 0.0659; + constants[101] = 0.0057938; + constants[102] = 0.06588648; + constants[103] = 46.4; + constants[113] = 0.0043; + constants[114] = 0.0139; + constants[115] = 0.0021; + constants[116] = 0.00694; + constants[117] = 0.00427806; + constants[118] = 0.0138823; + constants[119] = 45.0; + constants[129] = 0.00491; + constants[130] = 0.03649; + constants[131] = 0.004905; + constants[132] = 0.0365; + constants[133] = 0.004905; + constants[134] = 0.036495; + constants[136] = 6.65e-5; + constants[137] = 0.0114; + constants[138] = 0.000266; + constants[139] = 0.0114; + constants[140] = 6.645504e-5; + constants[141] = 0.01138376; + constants[147] = 0.000797; + constants[148] = 0.016; + constants[149] = 0.000738; + constants[150] = 0.0208; + constants[151] = 0.00079704; + constants[152] = 0.016; + constants[161] = 0.000518; + constants[162] = 0.0104; + constants[163] = 0.000345; + constants[164] = 0.0104; + constants[165] = 0.0003445; + constants[166] = 0.0104; + constants[170] = 0.000548; + constants[171] = 0.0069; + constants[172] = 0.000437; + constants[173] = 0.0055; + constants[174] = 0.0005465; + constants[175] = 0.006875; + constants[177] = 0.000548; + constants[178] = 0.0069; + constants[179] = 0.000437; + constants[180] = 0.0055; + constants[181] = 0.0005465; + constants[182] = 0.006875; states[0] = -39.013558536; states[1] = 0.092361701692; states[2] = 0.015905380261; @@ -379,154 +379,154 @@ void initialiseVariables(double *states, double *rates, double *constants) void computeComputedConstants(double *constants, double *computedConstants) { - variables[0] = (variables[2] == 0.0)?1.07*(3.0*variables[1]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295))):(variables[2] == 1.0)?variables[3]*variables[1]/(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295)):1.07*29.0*variables[1]/(30.0*(1.0+0.7745*exp(-(29.0*variables[1]-24.5)/1.95))); - variables[4] = variables[5]+variables[0]*(variables[6]-variables[5]); - variables[25] = (variables[2] == 0.0)?variables[26]+variables[0]*(variables[27]-variables[26]):(variables[2] == 1.0)?variables[30]+variables[0]*(variables[31]-variables[30]):variables[28]+variables[0]*(variables[29]-variables[28]); - variables[33] = (variables[2] == 0.0)?variables[34]+variables[0]*(variables[35]-variables[34]):(variables[2] == 1.0)?variables[38]+variables[0]*(variables[39]-variables[38]):variables[36]+variables[0]*(variables[37]-variables[36]); - variables[41] = (variables[2] == 0.0)?variables[42]+variables[0]*(variables[43]-variables[42]):(variables[2] == 1.0)?variables[46]+variables[0]*(variables[47]-variables[46]):variables[44]+variables[0]*(variables[45]-variables[44]); - variables[49] = (variables[2] == 0.0)?variables[50]+variables[0]*(variables[51]-variables[50]):(variables[2] == 1.0)?variables[54]+variables[0]*(variables[55]-variables[54]):variables[52]+variables[0]*(variables[53]-variables[52]); - variables[62] = (variables[2] == 0.0)?variables[63]+variables[0]*(variables[64]-variables[63]):(variables[2] == 1.0)?variables[67]+variables[0]*(variables[68]-variables[67]):variables[65]+variables[0]*(variables[66]-variables[65]); - variables[72] = (variables[2] == 0.0)?variables[73]+variables[0]*(variables[74]-variables[73]):(variables[2] == 1.0)?variables[77]+variables[0]*(variables[78]-variables[77]):variables[75]+variables[0]*(variables[76]-variables[75]); - variables[8] = variables[72]*variables[60]/(variables[60]+0.0004); - variables[32] = variables[22]*variables[23]/variables[24]*log(variables[59]/variables[56]); - variables[40] = variables[22]*variables[23]/variables[24]*log(variables[69]/variables[79]); - variables[48] = variables[22]*variables[23]/(2.0*variables[24])*log(variables[58]/variables[60]); - variables[80] = (variables[2] == 0.0)?variables[22]*variables[23]/variables[24]*log((variables[69]+0.12*variables[59])/(variables[79]+0.12*variables[56])):variables[22]*variables[23]/variables[24]*log((variables[69]+0.03*variables[59])/(variables[79]+0.03*variables[56])); - variables[81] = (variables[2] == 0.0)?variables[82]+variables[0]*(variables[83]-variables[82]):(variables[2] == 1.0)?variables[86]+variables[0]*(variables[87]-variables[86]):variables[84]+variables[0]*(variables[85]-variables[84]); - variables[96] = (variables[2] == 0.0)?variables[97]+variables[0]*(variables[98]-variables[97]):(variables[2] == 1.0)?variables[101]+variables[0]*(variables[102]-variables[101]):variables[99]+variables[0]*(variables[100]-variables[99]); - variables[112] = (variables[2] == 0.0)?variables[113]+variables[0]*(variables[114]-variables[113]):(variables[2] == 1.0)?variables[117]+variables[0]*(variables[118]-variables[117]):variables[115]+variables[0]*(variables[116]-variables[115]); - variables[128] = (variables[2] == 0.0)?variables[129]+variables[0]*(variables[130]-variables[129]):(variables[2] == 1.0)?variables[133]+variables[0]*(variables[134]-variables[133]):variables[131]+variables[0]*(variables[132]-variables[131]); - variables[135] = (variables[2] == 0.0)?variables[136]+variables[0]*(variables[137]-variables[136]):(variables[2] == 1.0)?variables[140]+variables[0]*(variables[141]-variables[140]):variables[138]+variables[0]*(variables[139]-variables[138]); - variables[146] = (variables[2] == 0.0)?variables[147]+variables[0]*(variables[148]-variables[147]):(variables[2] == 1.0)?variables[151]+variables[0]*(variables[152]-variables[151]):variables[149]+variables[0]*(variables[150]-variables[149]); - variables[158] = (variables[2] == 0.0)?0.002:(variables[2] == 1.0)?0.002:0.006; - variables[160] = (variables[2] == 0.0)?variables[161]+variables[0]*(variables[162]-variables[161]):(variables[2] == 1.0)?variables[165]+variables[0]*(variables[166]-variables[165]):variables[163]+variables[0]*(variables[164]-variables[163]); - variables[169] = (variables[2] == 0.0)?variables[170]+variables[0]*(variables[171]-variables[170]):(variables[2] == 1.0)?variables[174]+variables[0]*(variables[175]-variables[174]):variables[172]+variables[0]*(variables[173]-variables[172]); - variables[176] = (variables[2] == 0.0)?variables[177]+variables[0]*(variables[178]-variables[177]):(variables[2] == 1.0)?variables[181]+variables[0]*(variables[182]-variables[181]):variables[179]+variables[0]*(variables[180]-variables[179]); + computedConstants[0] = (constants[2] == 0.0)?1.07*(3.0*constants[1]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*constants[1]-2.05)/0.295))):(constants[2] == 1.0)?constants[3]*constants[1]/(1.0+0.7745*exp(-(3.0*constants[1]-2.05)/0.295)):1.07*29.0*constants[1]/(30.0*(1.0+0.7745*exp(-(29.0*constants[1]-24.5)/1.95))); + computedConstants[4] = constants[5]+computedConstants[0]*(constants[6]-constants[5]); + computedConstants[25] = (constants[2] == 0.0)?constants[26]+computedConstants[0]*(constants[27]-constants[26]):(constants[2] == 1.0)?constants[30]+computedConstants[0]*(constants[31]-constants[30]):constants[28]+computedConstants[0]*(constants[29]-constants[28]); + computedConstants[33] = (constants[2] == 0.0)?constants[34]+computedConstants[0]*(constants[35]-constants[34]):(constants[2] == 1.0)?constants[38]+computedConstants[0]*(constants[39]-constants[38]):constants[36]+computedConstants[0]*(constants[37]-constants[36]); + computedConstants[41] = (constants[2] == 0.0)?constants[42]+computedConstants[0]*(constants[43]-constants[42]):(constants[2] == 1.0)?constants[46]+computedConstants[0]*(constants[47]-constants[46]):constants[44]+computedConstants[0]*(constants[45]-constants[44]); + computedConstants[49] = (constants[2] == 0.0)?constants[50]+computedConstants[0]*(constants[51]-constants[50]):(constants[2] == 1.0)?constants[54]+computedConstants[0]*(constants[55]-constants[54]):constants[52]+computedConstants[0]*(constants[53]-constants[52]); + computedConstants[62] = (constants[2] == 0.0)?constants[63]+computedConstants[0]*(constants[64]-constants[63]):(constants[2] == 1.0)?constants[67]+computedConstants[0]*(constants[68]-constants[67]):constants[65]+computedConstants[0]*(constants[66]-constants[65]); + computedConstants[72] = (constants[2] == 0.0)?constants[73]+computedConstants[0]*(constants[74]-constants[73]):(constants[2] == 1.0)?constants[77]+computedConstants[0]*(constants[78]-constants[77]):constants[75]+computedConstants[0]*(constants[76]-constants[75]); + computedConstants[8] = computedConstants[72]*constants[60]/(constants[60]+0.0004); + computedConstants[32] = constants[22]*constants[23]/constants[24]*log(constants[59]/constants[56]); + computedConstants[40] = constants[22]*constants[23]/constants[24]*log(constants[69]/constants[79]); + computedConstants[48] = constants[22]*constants[23]/(2.0*constants[24])*log(constants[58]/constants[60]); + computedConstants[80] = (constants[2] == 0.0)?constants[22]*constants[23]/constants[24]*log((constants[69]+0.12*constants[59])/(constants[79]+0.12*constants[56])):constants[22]*constants[23]/constants[24]*log((constants[69]+0.03*constants[59])/(constants[79]+0.03*constants[56])); + computedConstants[81] = (constants[2] == 0.0)?constants[82]+computedConstants[0]*(constants[83]-constants[82]):(constants[2] == 1.0)?constants[86]+computedConstants[0]*(constants[87]-constants[86]):constants[84]+computedConstants[0]*(constants[85]-constants[84]); + computedConstants[96] = (constants[2] == 0.0)?constants[97]+computedConstants[0]*(constants[98]-constants[97]):(constants[2] == 1.0)?constants[101]+computedConstants[0]*(constants[102]-constants[101]):constants[99]+computedConstants[0]*(constants[100]-constants[99]); + computedConstants[112] = (constants[2] == 0.0)?constants[113]+computedConstants[0]*(constants[114]-constants[113]):(constants[2] == 1.0)?constants[117]+computedConstants[0]*(constants[118]-constants[117]):constants[115]+computedConstants[0]*(constants[116]-constants[115]); + computedConstants[128] = (constants[2] == 0.0)?constants[129]+computedConstants[0]*(constants[130]-constants[129]):(constants[2] == 1.0)?constants[133]+computedConstants[0]*(constants[134]-constants[133]):constants[131]+computedConstants[0]*(constants[132]-constants[131]); + computedConstants[135] = (constants[2] == 0.0)?constants[136]+computedConstants[0]*(constants[137]-constants[136]):(constants[2] == 1.0)?constants[140]+computedConstants[0]*(constants[141]-constants[140]):constants[138]+computedConstants[0]*(constants[139]-constants[138]); + computedConstants[146] = (constants[2] == 0.0)?constants[147]+computedConstants[0]*(constants[148]-constants[147]):(constants[2] == 1.0)?constants[151]+computedConstants[0]*(constants[152]-constants[151]):constants[149]+computedConstants[0]*(constants[150]-constants[149]); + computedConstants[158] = (constants[2] == 0.0)?0.002:(constants[2] == 1.0)?0.002:0.006; + computedConstants[160] = (constants[2] == 0.0)?constants[161]+computedConstants[0]*(constants[162]-constants[161]):(constants[2] == 1.0)?constants[165]+computedConstants[0]*(constants[166]-constants[165]):constants[163]+computedConstants[0]*(constants[164]-constants[163]); + computedConstants[169] = (constants[2] == 0.0)?constants[170]+computedConstants[0]*(constants[171]-constants[170]):(constants[2] == 1.0)?constants[174]+computedConstants[0]*(constants[175]-constants[174]):constants[172]+computedConstants[0]*(constants[173]-constants[172]); + computedConstants[176] = (constants[2] == 0.0)?constants[177]+computedConstants[0]*(constants[178]-constants[177]):(constants[2] == 1.0)?constants[181]+computedConstants[0]*(constants[182]-constants[181]):constants[179]+computedConstants[0]*(constants[180]-constants[179]); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[9] = variables[62]*pow(variables[56]/(variables[71]+variables[56]), 3.0)*pow(variables[69]/(variables[70]+variables[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); - variables[10] = (variables[2] == 0.0)?variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.0374*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))):variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.03743*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))); - variables[14] = (variables[2] != 2.0)?variables[176]*states[14]*(states[0]-variables[40]):variables[176]*states[14]*(states[0]+102.0); - variables[15] = (variables[2] != 2.0)?variables[169]*states[14]*(states[0]-variables[32]):variables[169]*states[14]*(states[0]-77.6); - variables[16] = variables[160]*pow(states[13], 2.0)*(states[0]-variables[80]); - variables[18] = variables[135]*states[8]*(states[0]-variables[40]); - variables[19] = variables[128]*states[9]*states[8]*(states[0]-variables[40]); - variables[20] = variables[112]*states[7]*states[6]*(states[0]-variables[119]); - variables[21] = variables[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-variables[103]); - variables[91] = (variables[2] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; - variables[88] = (1.0-variables[91])*states[2]+variables[91]*states[3]; - variables[7] = variables[81]*pow(states[1], 3.0)*variables[88]*variables[59]*pow(variables[24], 2.0)/(variables[22]*variables[23])*(exp((states[0]-variables[32])*variables[24]/(variables[22]*variables[23]))-1.0)/(exp(states[0]*variables[24]/(variables[22]*variables[23]))-1.0)*states[0]; - variables[11] = variables[33]*(states[0]-variables[40]); - variables[12] = variables[41]*(states[0]-variables[48]); - variables[13] = variables[25]*(states[0]-variables[32]); - variables[153] = 0.6*states[11]+0.4*states[12]; - variables[17] = variables[146]*variables[153]*states[10]*(states[0]-variables[40]); - rates[0] = -1.0/variables[4]*(variables[7]+variables[21]+variables[20]+variables[19]+variables[18]+variables[17]+variables[16]+variables[15]+variables[14]+variables[13]+variables[12]+variables[11]+variables[10]+variables[9]+variables[8]); - variables[89] = (variables[2] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); - variables[90] = (variables[2] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; - rates[1] = (variables[89]-states[1])/variables[90]; - variables[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); - variables[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; - rates[2] = (variables[92]-states[2])/variables[93]; - variables[94] = variables[92]; - variables[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; - rates[3] = (variables[94]-states[3])/variables[95]; - variables[104] = (variables[2] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(variables[2] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*variables[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); - variables[106] = (variables[2] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(variables[2] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); - variables[107] = (variables[2] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); - variables[105] = 2.0/(variables[106]+variables[107]); - rates[5] = (variables[104]-states[5])/variables[105]; - variables[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); - variables[110] = (variables[2] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); - variables[111] = (variables[2] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); - variables[109] = (variables[2] == 1.0)?(1.2-0.2*variables[0])/(variables[110]+variables[111]):1.0/(variables[110]+variables[111]); - rates[4] = (variables[108]-states[4])/variables[109]; - variables[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); - variables[122] = 1068.0*exp((states[0]+26.3)/30.0); - variables[123] = 1068.0*exp(-(states[0]+26.3)/30.0); - variables[121] = 1.0/(variables[122]+variables[123]); - rates[7] = (variables[120]-states[7])/variables[121]; - variables[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); - variables[126] = (variables[2] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*variables[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); - variables[127] = (variables[2] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); - variables[125] = 1.0/(variables[126]+variables[127]); - rates[6] = (variables[124]-states[6])/variables[125]; - variables[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); - variables[143] = (variables[2] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(variables[2] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*variables[0]))+0.7174*exp((0.2719-0.1719*variables[0])*1.0*(states[0]+40.93+10.0*variables[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); - rates[9] = (variables[142]-states[9])/variables[143]; - variables[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); - variables[145] = (variables[2] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(variables[2] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); - rates[8] = (variables[144]-states[8])/variables[145]; - variables[154] = (variables[2] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); - variables[155] = (variables[2] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); - rates[11] = (variables[154]-states[11])/variables[155]; - variables[156] = variables[154]; - variables[157] = (variables[2] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); - rates[12] = (variables[156]-states[12])/variables[157]; - variables[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); - rates[10] = (variables[159]-states[10])/variables[158]; - variables[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); - variables[168] = 1.0*exp(-states[0]/45.0); - rates[13] = variables[167]*(1.0-states[13])-variables[168]*states[13]; - variables[183] = (variables[2] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); - variables[184] = 1.0*exp((states[0]+75.13)/21.25); - rates[14] = variables[183]*(1.0-states[14])-variables[184]*states[14]; + algebraic[9] = computedConstants[62]*pow(constants[56]/(constants[71]+constants[56]), 3.0)*pow(constants[69]/(constants[70]+constants[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); + algebraic[10] = (constants[2] == 0.0)?computedConstants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.0374*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))):computedConstants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.03743*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))); + algebraic[14] = (constants[2] != 2.0)?computedConstants[176]*states[14]*(states[0]-computedConstants[40]):computedConstants[176]*states[14]*(states[0]+102.0); + algebraic[15] = (constants[2] != 2.0)?computedConstants[169]*states[14]*(states[0]-computedConstants[32]):computedConstants[169]*states[14]*(states[0]-77.6); + algebraic[16] = computedConstants[160]*pow(states[13], 2.0)*(states[0]-computedConstants[80]); + algebraic[18] = computedConstants[135]*states[8]*(states[0]-computedConstants[40]); + algebraic[19] = computedConstants[128]*states[9]*states[8]*(states[0]-computedConstants[40]); + algebraic[20] = computedConstants[112]*states[7]*states[6]*(states[0]-constants[119]); + algebraic[21] = computedConstants[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[103]); + algebraic[91] = (constants[2] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; + algebraic[88] = (1.0-algebraic[91])*states[2]+algebraic[91]*states[3]; + algebraic[7] = computedConstants[81]*pow(states[1], 3.0)*algebraic[88]*constants[59]*pow(constants[24], 2.0)/(constants[22]*constants[23])*(exp((states[0]-computedConstants[32])*constants[24]/(constants[22]*constants[23]))-1.0)/(exp(states[0]*constants[24]/(constants[22]*constants[23]))-1.0)*states[0]; + algebraic[11] = computedConstants[33]*(states[0]-computedConstants[40]); + algebraic[12] = computedConstants[41]*(states[0]-computedConstants[48]); + algebraic[13] = computedConstants[25]*(states[0]-computedConstants[32]); + algebraic[153] = 0.6*states[11]+0.4*states[12]; + algebraic[17] = computedConstants[146]*algebraic[153]*states[10]*(states[0]-computedConstants[40]); + rates[0] = -1.0/computedConstants[4]*(algebraic[7]+algebraic[21]+algebraic[20]+algebraic[19]+algebraic[18]+algebraic[17]+algebraic[16]+algebraic[15]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+computedConstants[8]); + algebraic[89] = (constants[2] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); + algebraic[90] = (constants[2] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; + rates[1] = (algebraic[89]-states[1])/algebraic[90]; + algebraic[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); + algebraic[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; + rates[2] = (algebraic[92]-states[2])/algebraic[93]; + algebraic[94] = algebraic[92]; + algebraic[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; + rates[3] = (algebraic[94]-states[3])/algebraic[95]; + algebraic[104] = (constants[2] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[2] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); + algebraic[106] = (constants[2] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[2] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); + algebraic[107] = (constants[2] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); + algebraic[105] = 2.0/(algebraic[106]+algebraic[107]); + rates[5] = (algebraic[104]-states[5])/algebraic[105]; + algebraic[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); + algebraic[110] = (constants[2] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); + algebraic[111] = (constants[2] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); + algebraic[109] = (constants[2] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[110]+algebraic[111]):1.0/(algebraic[110]+algebraic[111]); + rates[4] = (algebraic[108]-states[4])/algebraic[109]; + algebraic[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); + algebraic[122] = 1068.0*exp((states[0]+26.3)/30.0); + algebraic[123] = 1068.0*exp(-(states[0]+26.3)/30.0); + algebraic[121] = 1.0/(algebraic[122]+algebraic[123]); + rates[7] = (algebraic[120]-states[7])/algebraic[121]; + algebraic[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); + algebraic[126] = (constants[2] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); + algebraic[127] = (constants[2] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); + algebraic[125] = 1.0/(algebraic[126]+algebraic[127]); + rates[6] = (algebraic[124]-states[6])/algebraic[125]; + algebraic[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); + algebraic[143] = (constants[2] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[2] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); + rates[9] = (algebraic[142]-states[9])/algebraic[143]; + algebraic[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); + algebraic[145] = (constants[2] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[2] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); + rates[8] = (algebraic[144]-states[8])/algebraic[145]; + algebraic[154] = (constants[2] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); + algebraic[155] = (constants[2] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); + rates[11] = (algebraic[154]-states[11])/algebraic[155]; + algebraic[156] = algebraic[154]; + algebraic[157] = (constants[2] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); + rates[12] = (algebraic[156]-states[12])/algebraic[157]; + algebraic[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); + rates[10] = (algebraic[159]-states[10])/computedConstants[158]; + algebraic[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); + algebraic[168] = 1.0*exp(-states[0]/45.0); + rates[13] = algebraic[167]*(1.0-states[13])-algebraic[168]*states[13]; + algebraic[183] = (constants[2] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); + algebraic[184] = 1.0*exp((states[0]+75.13)/21.25); + rates[14] = algebraic[183]*(1.0-states[14])-algebraic[184]*states[14]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[13] = variables[25]*(states[0]-variables[32]); - variables[11] = variables[33]*(states[0]-variables[40]); - variables[12] = variables[41]*(states[0]-variables[48]); - variables[10] = (variables[2] == 0.0)?variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.0374*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))):variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.03743*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))); - variables[9] = variables[62]*pow(variables[56]/(variables[71]+variables[56]), 3.0)*pow(variables[69]/(variables[70]+variables[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); - variables[91] = (variables[2] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; - variables[88] = (1.0-variables[91])*states[2]+variables[91]*states[3]; - variables[7] = variables[81]*pow(states[1], 3.0)*variables[88]*variables[59]*pow(variables[24], 2.0)/(variables[22]*variables[23])*(exp((states[0]-variables[32])*variables[24]/(variables[22]*variables[23]))-1.0)/(exp(states[0]*variables[24]/(variables[22]*variables[23]))-1.0)*states[0]; - variables[89] = (variables[2] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); - variables[90] = (variables[2] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; - variables[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); - variables[94] = variables[92]; - variables[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; - variables[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; - variables[21] = variables[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-variables[103]); - variables[106] = (variables[2] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(variables[2] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); - variables[107] = (variables[2] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); - variables[105] = 2.0/(variables[106]+variables[107]); - variables[104] = (variables[2] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(variables[2] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*variables[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); - variables[110] = (variables[2] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); - variables[111] = (variables[2] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); - variables[109] = (variables[2] == 1.0)?(1.2-0.2*variables[0])/(variables[110]+variables[111]):1.0/(variables[110]+variables[111]); - variables[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); - variables[20] = variables[112]*states[7]*states[6]*(states[0]-variables[119]); - variables[122] = 1068.0*exp((states[0]+26.3)/30.0); - variables[123] = 1068.0*exp(-(states[0]+26.3)/30.0); - variables[121] = 1.0/(variables[122]+variables[123]); - variables[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); - variables[126] = (variables[2] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*variables[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); - variables[127] = (variables[2] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); - variables[125] = 1.0/(variables[126]+variables[127]); - variables[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); - variables[19] = variables[128]*states[9]*states[8]*(states[0]-variables[40]); - variables[18] = variables[135]*states[8]*(states[0]-variables[40]); - variables[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); - variables[143] = (variables[2] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(variables[2] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*variables[0]))+0.7174*exp((0.2719-0.1719*variables[0])*1.0*(states[0]+40.93+10.0*variables[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); - variables[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); - variables[145] = (variables[2] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(variables[2] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); - variables[153] = 0.6*states[11]+0.4*states[12]; - variables[17] = variables[146]*variables[153]*states[10]*(states[0]-variables[40]); - variables[154] = (variables[2] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); - variables[155] = (variables[2] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); - variables[156] = variables[154]; - variables[157] = (variables[2] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); - variables[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); - variables[16] = variables[160]*pow(states[13], 2.0)*(states[0]-variables[80]); - variables[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); - variables[168] = 1.0*exp(-states[0]/45.0); - variables[15] = (variables[2] != 2.0)?variables[169]*states[14]*(states[0]-variables[32]):variables[169]*states[14]*(states[0]-77.6); - variables[14] = (variables[2] != 2.0)?variables[176]*states[14]*(states[0]-variables[40]):variables[176]*states[14]*(states[0]+102.0); - variables[183] = (variables[2] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); - variables[184] = 1.0*exp((states[0]+75.13)/21.25); + algebraic[13] = computedConstants[25]*(states[0]-computedConstants[32]); + algebraic[11] = computedConstants[33]*(states[0]-computedConstants[40]); + algebraic[12] = computedConstants[41]*(states[0]-computedConstants[48]); + algebraic[10] = (constants[2] == 0.0)?computedConstants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.0374*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))):computedConstants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.03743*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))); + algebraic[9] = computedConstants[62]*pow(constants[56]/(constants[71]+constants[56]), 3.0)*pow(constants[69]/(constants[70]+constants[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); + algebraic[91] = (constants[2] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; + algebraic[88] = (1.0-algebraic[91])*states[2]+algebraic[91]*states[3]; + algebraic[7] = computedConstants[81]*pow(states[1], 3.0)*algebraic[88]*constants[59]*pow(constants[24], 2.0)/(constants[22]*constants[23])*(exp((states[0]-computedConstants[32])*constants[24]/(constants[22]*constants[23]))-1.0)/(exp(states[0]*constants[24]/(constants[22]*constants[23]))-1.0)*states[0]; + algebraic[89] = (constants[2] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); + algebraic[90] = (constants[2] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; + algebraic[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); + algebraic[94] = algebraic[92]; + algebraic[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; + algebraic[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; + algebraic[21] = computedConstants[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[103]); + algebraic[106] = (constants[2] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[2] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); + algebraic[107] = (constants[2] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); + algebraic[105] = 2.0/(algebraic[106]+algebraic[107]); + algebraic[104] = (constants[2] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[2] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); + algebraic[110] = (constants[2] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); + algebraic[111] = (constants[2] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); + algebraic[109] = (constants[2] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[110]+algebraic[111]):1.0/(algebraic[110]+algebraic[111]); + algebraic[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); + algebraic[20] = computedConstants[112]*states[7]*states[6]*(states[0]-constants[119]); + algebraic[122] = 1068.0*exp((states[0]+26.3)/30.0); + algebraic[123] = 1068.0*exp(-(states[0]+26.3)/30.0); + algebraic[121] = 1.0/(algebraic[122]+algebraic[123]); + algebraic[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); + algebraic[126] = (constants[2] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); + algebraic[127] = (constants[2] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); + algebraic[125] = 1.0/(algebraic[126]+algebraic[127]); + algebraic[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); + algebraic[19] = computedConstants[128]*states[9]*states[8]*(states[0]-computedConstants[40]); + algebraic[18] = computedConstants[135]*states[8]*(states[0]-computedConstants[40]); + algebraic[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); + algebraic[143] = (constants[2] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[2] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); + algebraic[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); + algebraic[145] = (constants[2] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[2] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); + algebraic[153] = 0.6*states[11]+0.4*states[12]; + algebraic[17] = computedConstants[146]*algebraic[153]*states[10]*(states[0]-computedConstants[40]); + algebraic[154] = (constants[2] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); + algebraic[155] = (constants[2] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); + algebraic[156] = algebraic[154]; + algebraic[157] = (constants[2] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); + algebraic[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); + algebraic[16] = computedConstants[160]*pow(states[13], 2.0)*(states[0]-computedConstants[80]); + algebraic[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); + algebraic[168] = 1.0*exp(-states[0]/45.0); + algebraic[15] = (constants[2] != 2.0)?computedConstants[169]*states[14]*(states[0]-computedConstants[32]):computedConstants[169]*states[14]*(states[0]-77.6); + algebraic[14] = (constants[2] != 2.0)?computedConstants[176]*states[14]*(states[0]-computedConstants[40]):computedConstants[176]*states[14]*(states[0]+102.0); + algebraic[183] = (constants[2] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); + algebraic[184] = 1.0*exp((states[0]+75.13)/21.25); } diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 4a43aaffe..241a885d1 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -247,116 +247,116 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[1] = 0.0 - variables[2] = 1.0 - variables[3] = 1.0309347 - variables[5] = 2.0e-5 - variables[6] = 6.5e-5 - variables[22] = 8314.0 - variables[23] = 310.0 - variables[24] = 96845.0 - variables[26] = 5.8e-5 - variables[27] = 0.000189 - variables[28] = 5.8e-5 - variables[29] = 0.000189 - variables[30] = 5.81818e-5 - variables[31] = 0.0001888 - variables[34] = 2.52e-5 - variables[35] = 8.19e-5 - variables[36] = 2.52e-5 - variables[37] = 8.19e-5 - variables[38] = 2.523636e-5 - variables[39] = 8.1892e-5 - variables[42] = 1.32e-5 - variables[43] = 4.3e-5 - variables[44] = 1.323e-5 - variables[45] = 4.29e-5 - variables[46] = 1.3236e-5 - variables[47] = 4.2952e-5 - variables[50] = 2.7e-6 - variables[51] = 8.8e-6 - variables[52] = 2.8e-6 - variables[53] = 8.8e-6 - variables[54] = 2.7229e-6 - variables[55] = 8.83584e-6 - variables[56] = 8.0 - variables[57] = 0.5 - variables[58] = 2.0 - variables[59] = 140.0 - variables[60] = 0.0001 - variables[61] = 0.0001 - variables[63] = 0.0478 - variables[64] = 0.16 - variables[65] = 0.0478 - variables[66] = 0.16 - variables[67] = 0.04782545 - variables[68] = 0.1551936 - variables[69] = 5.4 - variables[70] = 0.621 - variables[71] = 5.64 - variables[73] = 0.0 - variables[74] = 0.0 - variables[75] = 0.0042 - variables[76] = 0.03339 - variables[77] = 0.0 - variables[78] = 0.0 - variables[79] = 140.0 - variables[82] = 0.0 - variables[83] = 1.2e-6 - variables[84] = 0.0 - variables[85] = 3.7e-7 - variables[86] = 0.0 - variables[87] = 1.204e-6 - variables[97] = 0.0058 - variables[98] = 0.0659 - variables[99] = 0.0082 - variables[100] = 0.0659 - variables[101] = 0.0057938 - variables[102] = 0.06588648 - variables[103] = 46.4 - variables[113] = 0.0043 - variables[114] = 0.0139 - variables[115] = 0.0021 - variables[116] = 0.00694 - variables[117] = 0.00427806 - variables[118] = 0.0138823 - variables[119] = 45.0 - variables[129] = 0.00491 - variables[130] = 0.03649 - variables[131] = 0.004905 - variables[132] = 0.0365 - variables[133] = 0.004905 - variables[134] = 0.036495 - variables[136] = 6.65e-5 - variables[137] = 0.0114 - variables[138] = 0.000266 - variables[139] = 0.0114 - variables[140] = 6.645504e-5 - variables[141] = 0.01138376 - variables[147] = 0.000797 - variables[148] = 0.016 - variables[149] = 0.000738 - variables[150] = 0.0208 - variables[151] = 0.00079704 - variables[152] = 0.016 - variables[161] = 0.000518 - variables[162] = 0.0104 - variables[163] = 0.000345 - variables[164] = 0.0104 - variables[165] = 0.0003445 - variables[166] = 0.0104 - variables[170] = 0.000548 - variables[171] = 0.0069 - variables[172] = 0.000437 - variables[173] = 0.0055 - variables[174] = 0.0005465 - variables[175] = 0.006875 - variables[177] = 0.000548 - variables[178] = 0.0069 - variables[179] = 0.000437 - variables[180] = 0.0055 - variables[181] = 0.0005465 - variables[182] = 0.006875 + constants[1] = 0.0 + constants[2] = 1.0 + constants[3] = 1.0309347 + constants[5] = 2.0e-5 + constants[6] = 6.5e-5 + constants[22] = 8314.0 + constants[23] = 310.0 + constants[24] = 96845.0 + constants[26] = 5.8e-5 + constants[27] = 0.000189 + constants[28] = 5.8e-5 + constants[29] = 0.000189 + constants[30] = 5.81818e-5 + constants[31] = 0.0001888 + constants[34] = 2.52e-5 + constants[35] = 8.19e-5 + constants[36] = 2.52e-5 + constants[37] = 8.19e-5 + constants[38] = 2.523636e-5 + constants[39] = 8.1892e-5 + constants[42] = 1.32e-5 + constants[43] = 4.3e-5 + constants[44] = 1.323e-5 + constants[45] = 4.29e-5 + constants[46] = 1.3236e-5 + constants[47] = 4.2952e-5 + constants[50] = 2.7e-6 + constants[51] = 8.8e-6 + constants[52] = 2.8e-6 + constants[53] = 8.8e-6 + constants[54] = 2.7229e-6 + constants[55] = 8.83584e-6 + constants[56] = 8.0 + constants[57] = 0.5 + constants[58] = 2.0 + constants[59] = 140.0 + constants[60] = 0.0001 + constants[61] = 0.0001 + constants[63] = 0.0478 + constants[64] = 0.16 + constants[65] = 0.0478 + constants[66] = 0.16 + constants[67] = 0.04782545 + constants[68] = 0.1551936 + constants[69] = 5.4 + constants[70] = 0.621 + constants[71] = 5.64 + constants[73] = 0.0 + constants[74] = 0.0 + constants[75] = 0.0042 + constants[76] = 0.03339 + constants[77] = 0.0 + constants[78] = 0.0 + constants[79] = 140.0 + constants[82] = 0.0 + constants[83] = 1.2e-6 + constants[84] = 0.0 + constants[85] = 3.7e-7 + constants[86] = 0.0 + constants[87] = 1.204e-6 + constants[97] = 0.0058 + constants[98] = 0.0659 + constants[99] = 0.0082 + constants[100] = 0.0659 + constants[101] = 0.0057938 + constants[102] = 0.06588648 + constants[103] = 46.4 + constants[113] = 0.0043 + constants[114] = 0.0139 + constants[115] = 0.0021 + constants[116] = 0.00694 + constants[117] = 0.00427806 + constants[118] = 0.0138823 + constants[119] = 45.0 + constants[129] = 0.00491 + constants[130] = 0.03649 + constants[131] = 0.004905 + constants[132] = 0.0365 + constants[133] = 0.004905 + constants[134] = 0.036495 + constants[136] = 6.65e-5 + constants[137] = 0.0114 + constants[138] = 0.000266 + constants[139] = 0.0114 + constants[140] = 6.645504e-5 + constants[141] = 0.01138376 + constants[147] = 0.000797 + constants[148] = 0.016 + constants[149] = 0.000738 + constants[150] = 0.0208 + constants[151] = 0.00079704 + constants[152] = 0.016 + constants[161] = 0.000518 + constants[162] = 0.0104 + constants[163] = 0.000345 + constants[164] = 0.0104 + constants[165] = 0.0003445 + constants[166] = 0.0104 + constants[170] = 0.000548 + constants[171] = 0.0069 + constants[172] = 0.000437 + constants[173] = 0.0055 + constants[174] = 0.0005465 + constants[175] = 0.006875 + constants[177] = 0.000548 + constants[178] = 0.0069 + constants[179] = 0.000437 + constants[180] = 0.0055 + constants[181] = 0.0005465 + constants[182] = 0.006875 states[0] = -39.013558536 states[1] = 0.092361701692 states[2] = 0.015905380261 @@ -375,151 +375,151 @@ def initialise_variables(states, rates, constants): def compute_computed_constants(constants, computed_constants): - variables[0] = 1.07*(3.0*variables[1]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295))) if eq_func(variables[2], 0.0) else variables[3]*variables[1]/(1.0+0.7745*exp(-(3.0*variables[1]-2.05)/0.295)) if eq_func(variables[2], 1.0) else 1.07*29.0*variables[1]/(30.0*(1.0+0.7745*exp(-(29.0*variables[1]-24.5)/1.95))) - variables[4] = variables[5]+variables[0]*(variables[6]-variables[5]) - variables[25] = variables[26]+variables[0]*(variables[27]-variables[26]) if eq_func(variables[2], 0.0) else variables[30]+variables[0]*(variables[31]-variables[30]) if eq_func(variables[2], 1.0) else variables[28]+variables[0]*(variables[29]-variables[28]) - variables[33] = variables[34]+variables[0]*(variables[35]-variables[34]) if eq_func(variables[2], 0.0) else variables[38]+variables[0]*(variables[39]-variables[38]) if eq_func(variables[2], 1.0) else variables[36]+variables[0]*(variables[37]-variables[36]) - variables[41] = variables[42]+variables[0]*(variables[43]-variables[42]) if eq_func(variables[2], 0.0) else variables[46]+variables[0]*(variables[47]-variables[46]) if eq_func(variables[2], 1.0) else variables[44]+variables[0]*(variables[45]-variables[44]) - variables[49] = variables[50]+variables[0]*(variables[51]-variables[50]) if eq_func(variables[2], 0.0) else variables[54]+variables[0]*(variables[55]-variables[54]) if eq_func(variables[2], 1.0) else variables[52]+variables[0]*(variables[53]-variables[52]) - variables[62] = variables[63]+variables[0]*(variables[64]-variables[63]) if eq_func(variables[2], 0.0) else variables[67]+variables[0]*(variables[68]-variables[67]) if eq_func(variables[2], 1.0) else variables[65]+variables[0]*(variables[66]-variables[65]) - variables[72] = variables[73]+variables[0]*(variables[74]-variables[73]) if eq_func(variables[2], 0.0) else variables[77]+variables[0]*(variables[78]-variables[77]) if eq_func(variables[2], 1.0) else variables[75]+variables[0]*(variables[76]-variables[75]) - variables[8] = variables[72]*variables[60]/(variables[60]+0.0004) - variables[32] = variables[22]*variables[23]/variables[24]*log(variables[59]/variables[56]) - variables[40] = variables[22]*variables[23]/variables[24]*log(variables[69]/variables[79]) - variables[48] = variables[22]*variables[23]/(2.0*variables[24])*log(variables[58]/variables[60]) - variables[80] = variables[22]*variables[23]/variables[24]*log((variables[69]+0.12*variables[59])/(variables[79]+0.12*variables[56])) if eq_func(variables[2], 0.0) else variables[22]*variables[23]/variables[24]*log((variables[69]+0.03*variables[59])/(variables[79]+0.03*variables[56])) - variables[81] = variables[82]+variables[0]*(variables[83]-variables[82]) if eq_func(variables[2], 0.0) else variables[86]+variables[0]*(variables[87]-variables[86]) if eq_func(variables[2], 1.0) else variables[84]+variables[0]*(variables[85]-variables[84]) - variables[96] = variables[97]+variables[0]*(variables[98]-variables[97]) if eq_func(variables[2], 0.0) else variables[101]+variables[0]*(variables[102]-variables[101]) if eq_func(variables[2], 1.0) else variables[99]+variables[0]*(variables[100]-variables[99]) - variables[112] = variables[113]+variables[0]*(variables[114]-variables[113]) if eq_func(variables[2], 0.0) else variables[117]+variables[0]*(variables[118]-variables[117]) if eq_func(variables[2], 1.0) else variables[115]+variables[0]*(variables[116]-variables[115]) - variables[128] = variables[129]+variables[0]*(variables[130]-variables[129]) if eq_func(variables[2], 0.0) else variables[133]+variables[0]*(variables[134]-variables[133]) if eq_func(variables[2], 1.0) else variables[131]+variables[0]*(variables[132]-variables[131]) - variables[135] = variables[136]+variables[0]*(variables[137]-variables[136]) if eq_func(variables[2], 0.0) else variables[140]+variables[0]*(variables[141]-variables[140]) if eq_func(variables[2], 1.0) else variables[138]+variables[0]*(variables[139]-variables[138]) - variables[146] = variables[147]+variables[0]*(variables[148]-variables[147]) if eq_func(variables[2], 0.0) else variables[151]+variables[0]*(variables[152]-variables[151]) if eq_func(variables[2], 1.0) else variables[149]+variables[0]*(variables[150]-variables[149]) - variables[158] = 0.002 if eq_func(variables[2], 0.0) else 0.002 if eq_func(variables[2], 1.0) else 0.006 - variables[160] = variables[161]+variables[0]*(variables[162]-variables[161]) if eq_func(variables[2], 0.0) else variables[165]+variables[0]*(variables[166]-variables[165]) if eq_func(variables[2], 1.0) else variables[163]+variables[0]*(variables[164]-variables[163]) - variables[169] = variables[170]+variables[0]*(variables[171]-variables[170]) if eq_func(variables[2], 0.0) else variables[174]+variables[0]*(variables[175]-variables[174]) if eq_func(variables[2], 1.0) else variables[172]+variables[0]*(variables[173]-variables[172]) - variables[176] = variables[177]+variables[0]*(variables[178]-variables[177]) if eq_func(variables[2], 0.0) else variables[181]+variables[0]*(variables[182]-variables[181]) if eq_func(variables[2], 1.0) else variables[179]+variables[0]*(variables[180]-variables[179]) + computed_constants[0] = 1.07*(3.0*constants[1]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*constants[1]-2.05)/0.295))) if eq_func(constants[2], 0.0) else constants[3]*constants[1]/(1.0+0.7745*exp(-(3.0*constants[1]-2.05)/0.295)) if eq_func(constants[2], 1.0) else 1.07*29.0*constants[1]/(30.0*(1.0+0.7745*exp(-(29.0*constants[1]-24.5)/1.95))) + computed_constants[4] = constants[5]+computed_constants[0]*(constants[6]-constants[5]) + computed_constants[25] = constants[26]+computed_constants[0]*(constants[27]-constants[26]) if eq_func(constants[2], 0.0) else constants[30]+computed_constants[0]*(constants[31]-constants[30]) if eq_func(constants[2], 1.0) else constants[28]+computed_constants[0]*(constants[29]-constants[28]) + computed_constants[33] = constants[34]+computed_constants[0]*(constants[35]-constants[34]) if eq_func(constants[2], 0.0) else constants[38]+computed_constants[0]*(constants[39]-constants[38]) if eq_func(constants[2], 1.0) else constants[36]+computed_constants[0]*(constants[37]-constants[36]) + computed_constants[41] = constants[42]+computed_constants[0]*(constants[43]-constants[42]) if eq_func(constants[2], 0.0) else constants[46]+computed_constants[0]*(constants[47]-constants[46]) if eq_func(constants[2], 1.0) else constants[44]+computed_constants[0]*(constants[45]-constants[44]) + computed_constants[49] = constants[50]+computed_constants[0]*(constants[51]-constants[50]) if eq_func(constants[2], 0.0) else constants[54]+computed_constants[0]*(constants[55]-constants[54]) if eq_func(constants[2], 1.0) else constants[52]+computed_constants[0]*(constants[53]-constants[52]) + computed_constants[62] = constants[63]+computed_constants[0]*(constants[64]-constants[63]) if eq_func(constants[2], 0.0) else constants[67]+computed_constants[0]*(constants[68]-constants[67]) if eq_func(constants[2], 1.0) else constants[65]+computed_constants[0]*(constants[66]-constants[65]) + computed_constants[72] = constants[73]+computed_constants[0]*(constants[74]-constants[73]) if eq_func(constants[2], 0.0) else constants[77]+computed_constants[0]*(constants[78]-constants[77]) if eq_func(constants[2], 1.0) else constants[75]+computed_constants[0]*(constants[76]-constants[75]) + computed_constants[8] = computed_constants[72]*constants[60]/(constants[60]+0.0004) + computed_constants[32] = constants[22]*constants[23]/constants[24]*log(constants[59]/constants[56]) + computed_constants[40] = constants[22]*constants[23]/constants[24]*log(constants[69]/constants[79]) + computed_constants[48] = constants[22]*constants[23]/(2.0*constants[24])*log(constants[58]/constants[60]) + computed_constants[80] = constants[22]*constants[23]/constants[24]*log((constants[69]+0.12*constants[59])/(constants[79]+0.12*constants[56])) if eq_func(constants[2], 0.0) else constants[22]*constants[23]/constants[24]*log((constants[69]+0.03*constants[59])/(constants[79]+0.03*constants[56])) + computed_constants[81] = constants[82]+computed_constants[0]*(constants[83]-constants[82]) if eq_func(constants[2], 0.0) else constants[86]+computed_constants[0]*(constants[87]-constants[86]) if eq_func(constants[2], 1.0) else constants[84]+computed_constants[0]*(constants[85]-constants[84]) + computed_constants[96] = constants[97]+computed_constants[0]*(constants[98]-constants[97]) if eq_func(constants[2], 0.0) else constants[101]+computed_constants[0]*(constants[102]-constants[101]) if eq_func(constants[2], 1.0) else constants[99]+computed_constants[0]*(constants[100]-constants[99]) + computed_constants[112] = constants[113]+computed_constants[0]*(constants[114]-constants[113]) if eq_func(constants[2], 0.0) else constants[117]+computed_constants[0]*(constants[118]-constants[117]) if eq_func(constants[2], 1.0) else constants[115]+computed_constants[0]*(constants[116]-constants[115]) + computed_constants[128] = constants[129]+computed_constants[0]*(constants[130]-constants[129]) if eq_func(constants[2], 0.0) else constants[133]+computed_constants[0]*(constants[134]-constants[133]) if eq_func(constants[2], 1.0) else constants[131]+computed_constants[0]*(constants[132]-constants[131]) + computed_constants[135] = constants[136]+computed_constants[0]*(constants[137]-constants[136]) if eq_func(constants[2], 0.0) else constants[140]+computed_constants[0]*(constants[141]-constants[140]) if eq_func(constants[2], 1.0) else constants[138]+computed_constants[0]*(constants[139]-constants[138]) + computed_constants[146] = constants[147]+computed_constants[0]*(constants[148]-constants[147]) if eq_func(constants[2], 0.0) else constants[151]+computed_constants[0]*(constants[152]-constants[151]) if eq_func(constants[2], 1.0) else constants[149]+computed_constants[0]*(constants[150]-constants[149]) + computed_constants[158] = 0.002 if eq_func(constants[2], 0.0) else 0.002 if eq_func(constants[2], 1.0) else 0.006 + computed_constants[160] = constants[161]+computed_constants[0]*(constants[162]-constants[161]) if eq_func(constants[2], 0.0) else constants[165]+computed_constants[0]*(constants[166]-constants[165]) if eq_func(constants[2], 1.0) else constants[163]+computed_constants[0]*(constants[164]-constants[163]) + computed_constants[169] = constants[170]+computed_constants[0]*(constants[171]-constants[170]) if eq_func(constants[2], 0.0) else constants[174]+computed_constants[0]*(constants[175]-constants[174]) if eq_func(constants[2], 1.0) else constants[172]+computed_constants[0]*(constants[173]-constants[172]) + computed_constants[176] = constants[177]+computed_constants[0]*(constants[178]-constants[177]) if eq_func(constants[2], 0.0) else constants[181]+computed_constants[0]*(constants[182]-constants[181]) if eq_func(constants[2], 1.0) else constants[179]+computed_constants[0]*(constants[180]-constants[179]) def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - variables[9] = variables[62]*pow(variables[56]/(variables[71]+variables[56]), 3.0)*pow(variables[69]/(variables[70]+variables[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) - variables[10] = variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.0374*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))) if eq_func(variables[2], 0.0) else variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.03743*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))) - variables[14] = variables[176]*states[14]*(states[0]-variables[40]) if neq_func(variables[2], 2.0) else variables[176]*states[14]*(states[0]+102.0) - variables[15] = variables[169]*states[14]*(states[0]-variables[32]) if neq_func(variables[2], 2.0) else variables[169]*states[14]*(states[0]-77.6) - variables[16] = variables[160]*pow(states[13], 2.0)*(states[0]-variables[80]) - variables[18] = variables[135]*states[8]*(states[0]-variables[40]) - variables[19] = variables[128]*states[9]*states[8]*(states[0]-variables[40]) - variables[20] = variables[112]*states[7]*states[6]*(states[0]-variables[119]) - variables[21] = variables[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-variables[103]) - variables[91] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(variables[2], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 - variables[88] = (1.0-variables[91])*states[2]+variables[91]*states[3] - variables[7] = variables[81]*pow(states[1], 3.0)*variables[88]*variables[59]*pow(variables[24], 2.0)/(variables[22]*variables[23])*(exp((states[0]-variables[32])*variables[24]/(variables[22]*variables[23]))-1.0)/(exp(states[0]*variables[24]/(variables[22]*variables[23]))-1.0)*states[0] - variables[11] = variables[33]*(states[0]-variables[40]) - variables[12] = variables[41]*(states[0]-variables[48]) - variables[13] = variables[25]*(states[0]-variables[32]) - variables[153] = 0.6*states[11]+0.4*states[12] - variables[17] = variables[146]*variables[153]*states[10]*(states[0]-variables[40]) - rates[0] = -1.0/variables[4]*(variables[7]+variables[21]+variables[20]+variables[19]+variables[18]+variables[17]+variables[16]+variables[15]+variables[14]+variables[13]+variables[12]+variables[11]+variables[10]+variables[9]+variables[8]) - variables[89] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(variables[2], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) - variables[90] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(variables[2], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 - rates[1] = (variables[89]-states[1])/variables[90] - variables[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) - variables[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 - rates[2] = (variables[92]-states[2])/variables[93] - variables[94] = variables[92] - variables[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 - rates[3] = (variables[94]-states[3])/variables[95] - variables[104] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(variables[2], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*variables[0])/6.0)) if eq_func(variables[2], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) - variables[106] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(variables[2], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(variables[2], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) - variables[107] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(variables[2], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) - variables[105] = 2.0/(variables[106]+variables[107]) - rates[5] = (variables[104]-states[5])/variables[105] - variables[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) - variables[110] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(variables[2], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) - variables[111] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(variables[2], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) - variables[109] = (1.2-0.2*variables[0])/(variables[110]+variables[111]) if eq_func(variables[2], 1.0) else 1.0/(variables[110]+variables[111]) - rates[4] = (variables[108]-states[4])/variables[109] - variables[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) - variables[122] = 1068.0*exp((states[0]+26.3)/30.0) - variables[123] = 1068.0*exp(-(states[0]+26.3)/30.0) - variables[121] = 1.0/(variables[122]+variables[123]) - rates[7] = (variables[120]-states[7])/variables[121] - variables[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) - variables[126] = 15.3*exp(-(states[0]+71.0+0.7*variables[0])/83.3) if eq_func(variables[2], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) - variables[127] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(variables[2], 1.0) else 15.0*exp((states[0]+71.7)/15.38) - variables[125] = 1.0/(variables[126]+variables[127]) - rates[6] = (variables[124]-states[6])/variables[125] - variables[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) - variables[143] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(variables[2], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*variables[0]))+0.7174*exp((0.2719-0.1719*variables[0])*1.0*(states[0]+40.93+10.0*variables[0])))) if eq_func(variables[2], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) - rates[9] = (variables[142]-states[9])/variables[143] - variables[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) - variables[145] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(variables[2], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(variables[2], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) - rates[8] = (variables[144]-states[8])/variables[145] - variables[154] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(variables[2], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) - variables[155] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(variables[2], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) - rates[11] = (variables[154]-states[11])/variables[155] - variables[156] = variables[154] - variables[157] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(variables[2], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) - rates[12] = (variables[156]-states[12])/variables[157] - variables[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) - rates[10] = (variables[159]-states[10])/variables[158] - variables[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) - variables[168] = 1.0*exp(-states[0]/45.0) - rates[13] = variables[167]*(1.0-states[13])-variables[168]*states[13] - variables[183] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(variables[2], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) - variables[184] = 1.0*exp((states[0]+75.13)/21.25) - rates[14] = variables[183]*(1.0-states[14])-variables[184]*states[14] + algebraic[9] = computed_constants[62]*pow(constants[56]/(constants[71]+constants[56]), 3.0)*pow(constants[69]/(constants[70]+constants[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) + algebraic[10] = computed_constants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.0374*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))) if eq_func(constants[2], 0.0) else computed_constants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.03743*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))) + algebraic[14] = computed_constants[176]*states[14]*(states[0]-computed_constants[40]) if neq_func(constants[2], 2.0) else computed_constants[176]*states[14]*(states[0]+102.0) + algebraic[15] = computed_constants[169]*states[14]*(states[0]-computed_constants[32]) if neq_func(constants[2], 2.0) else computed_constants[169]*states[14]*(states[0]-77.6) + algebraic[16] = computed_constants[160]*pow(states[13], 2.0)*(states[0]-computed_constants[80]) + algebraic[18] = computed_constants[135]*states[8]*(states[0]-computed_constants[40]) + algebraic[19] = computed_constants[128]*states[9]*states[8]*(states[0]-computed_constants[40]) + algebraic[20] = computed_constants[112]*states[7]*states[6]*(states[0]-constants[119]) + algebraic[21] = computed_constants[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[103]) + algebraic[91] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[2], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 + algebraic[88] = (1.0-algebraic[91])*states[2]+algebraic[91]*states[3] + algebraic[7] = computed_constants[81]*pow(states[1], 3.0)*algebraic[88]*constants[59]*pow(constants[24], 2.0)/(constants[22]*constants[23])*(exp((states[0]-computed_constants[32])*constants[24]/(constants[22]*constants[23]))-1.0)/(exp(states[0]*constants[24]/(constants[22]*constants[23]))-1.0)*states[0] + algebraic[11] = computed_constants[33]*(states[0]-computed_constants[40]) + algebraic[12] = computed_constants[41]*(states[0]-computed_constants[48]) + algebraic[13] = computed_constants[25]*(states[0]-computed_constants[32]) + algebraic[153] = 0.6*states[11]+0.4*states[12] + algebraic[17] = computed_constants[146]*algebraic[153]*states[10]*(states[0]-computed_constants[40]) + rates[0] = -1.0/computed_constants[4]*(algebraic[7]+algebraic[21]+algebraic[20]+algebraic[19]+algebraic[18]+algebraic[17]+algebraic[16]+algebraic[15]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+computed_constants[8]) + algebraic[89] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[2], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) + algebraic[90] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[2], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 + rates[1] = (algebraic[89]-states[1])/algebraic[90] + algebraic[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) + algebraic[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 + rates[2] = (algebraic[92]-states[2])/algebraic[93] + algebraic[94] = algebraic[92] + algebraic[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 + rates[3] = (algebraic[94]-states[3])/algebraic[95] + algebraic[104] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[2], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[2], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) + algebraic[106] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[2], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[2], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) + algebraic[107] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[2], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) + algebraic[105] = 2.0/(algebraic[106]+algebraic[107]) + rates[5] = (algebraic[104]-states[5])/algebraic[105] + algebraic[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) + algebraic[110] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[2], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) + algebraic[111] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[2], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) + algebraic[109] = (1.2-0.2*computed_constants[0])/(algebraic[110]+algebraic[111]) if eq_func(constants[2], 1.0) else 1.0/(algebraic[110]+algebraic[111]) + rates[4] = (algebraic[108]-states[4])/algebraic[109] + algebraic[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) + algebraic[122] = 1068.0*exp((states[0]+26.3)/30.0) + algebraic[123] = 1068.0*exp(-(states[0]+26.3)/30.0) + algebraic[121] = 1.0/(algebraic[122]+algebraic[123]) + rates[7] = (algebraic[120]-states[7])/algebraic[121] + algebraic[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) + algebraic[126] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[2], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) + algebraic[127] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[2], 1.0) else 15.0*exp((states[0]+71.7)/15.38) + algebraic[125] = 1.0/(algebraic[126]+algebraic[127]) + rates[6] = (algebraic[124]-states[6])/algebraic[125] + algebraic[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) + algebraic[143] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[2], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[2], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) + rates[9] = (algebraic[142]-states[9])/algebraic[143] + algebraic[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) + algebraic[145] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[2], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[2], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) + rates[8] = (algebraic[144]-states[8])/algebraic[145] + algebraic[154] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[2], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) + algebraic[155] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[2], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) + rates[11] = (algebraic[154]-states[11])/algebraic[155] + algebraic[156] = algebraic[154] + algebraic[157] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[2], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) + rates[12] = (algebraic[156]-states[12])/algebraic[157] + algebraic[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) + rates[10] = (algebraic[159]-states[10])/computed_constants[158] + algebraic[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) + algebraic[168] = 1.0*exp(-states[0]/45.0) + rates[13] = algebraic[167]*(1.0-states[13])-algebraic[168]*states[13] + algebraic[183] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[2], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) + algebraic[184] = 1.0*exp((states[0]+75.13)/21.25) + rates[14] = algebraic[183]*(1.0-states[14])-algebraic[184]*states[14] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[13] = variables[25]*(states[0]-variables[32]) - variables[11] = variables[33]*(states[0]-variables[40]) - variables[12] = variables[41]*(states[0]-variables[48]) - variables[10] = variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.0374*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))) if eq_func(variables[2], 0.0) else variables[49]*(pow(variables[56], 3.0)*variables[58]*exp(0.03743*states[0]*variables[57])-pow(variables[59], 3.0)*variables[60]*exp(0.03743*states[0]*(variables[57]-1.0)))/(1.0+variables[61]*(variables[60]*pow(variables[59], 3.0)+variables[58]*pow(variables[56], 3.0))) - variables[9] = variables[62]*pow(variables[56]/(variables[71]+variables[56]), 3.0)*pow(variables[69]/(variables[70]+variables[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) - variables[91] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(variables[2], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 - variables[88] = (1.0-variables[91])*states[2]+variables[91]*states[3] - variables[7] = variables[81]*pow(states[1], 3.0)*variables[88]*variables[59]*pow(variables[24], 2.0)/(variables[22]*variables[23])*(exp((states[0]-variables[32])*variables[24]/(variables[22]*variables[23]))-1.0)/(exp(states[0]*variables[24]/(variables[22]*variables[23]))-1.0)*states[0] - variables[89] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(variables[2], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) - variables[90] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(variables[2], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 - variables[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) - variables[94] = variables[92] - variables[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 - variables[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 - variables[21] = variables[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-variables[103]) - variables[106] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(variables[2], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(variables[2], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) - variables[107] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(variables[2], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) - variables[105] = 2.0/(variables[106]+variables[107]) - variables[104] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(variables[2], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*variables[0])/6.0)) if eq_func(variables[2], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) - variables[110] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(variables[2], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) - variables[111] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(variables[2], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) - variables[109] = (1.2-0.2*variables[0])/(variables[110]+variables[111]) if eq_func(variables[2], 1.0) else 1.0/(variables[110]+variables[111]) - variables[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) - variables[20] = variables[112]*states[7]*states[6]*(states[0]-variables[119]) - variables[122] = 1068.0*exp((states[0]+26.3)/30.0) - variables[123] = 1068.0*exp(-(states[0]+26.3)/30.0) - variables[121] = 1.0/(variables[122]+variables[123]) - variables[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) - variables[126] = 15.3*exp(-(states[0]+71.0+0.7*variables[0])/83.3) if eq_func(variables[2], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) - variables[127] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(variables[2], 1.0) else 15.0*exp((states[0]+71.7)/15.38) - variables[125] = 1.0/(variables[126]+variables[127]) - variables[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) - variables[19] = variables[128]*states[9]*states[8]*(states[0]-variables[40]) - variables[18] = variables[135]*states[8]*(states[0]-variables[40]) - variables[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) - variables[143] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(variables[2], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*variables[0]))+0.7174*exp((0.2719-0.1719*variables[0])*1.0*(states[0]+40.93+10.0*variables[0])))) if eq_func(variables[2], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) - variables[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) - variables[145] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(variables[2], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(variables[2], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) - variables[153] = 0.6*states[11]+0.4*states[12] - variables[17] = variables[146]*variables[153]*states[10]*(states[0]-variables[40]) - variables[154] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(variables[2], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) - variables[155] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(variables[2], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) - variables[156] = variables[154] - variables[157] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(variables[2], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) - variables[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) - variables[16] = variables[160]*pow(states[13], 2.0)*(states[0]-variables[80]) - variables[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) - variables[168] = 1.0*exp(-states[0]/45.0) - variables[15] = variables[169]*states[14]*(states[0]-variables[32]) if neq_func(variables[2], 2.0) else variables[169]*states[14]*(states[0]-77.6) - variables[14] = variables[176]*states[14]*(states[0]-variables[40]) if neq_func(variables[2], 2.0) else variables[176]*states[14]*(states[0]+102.0) - variables[183] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(variables[2], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) - variables[184] = 1.0*exp((states[0]+75.13)/21.25) + algebraic[13] = computed_constants[25]*(states[0]-computed_constants[32]) + algebraic[11] = computed_constants[33]*(states[0]-computed_constants[40]) + algebraic[12] = computed_constants[41]*(states[0]-computed_constants[48]) + algebraic[10] = computed_constants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.0374*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))) if eq_func(constants[2], 0.0) else computed_constants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.03743*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))) + algebraic[9] = computed_constants[62]*pow(constants[56]/(constants[71]+constants[56]), 3.0)*pow(constants[69]/(constants[70]+constants[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) + algebraic[91] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[2], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 + algebraic[88] = (1.0-algebraic[91])*states[2]+algebraic[91]*states[3] + algebraic[7] = computed_constants[81]*pow(states[1], 3.0)*algebraic[88]*constants[59]*pow(constants[24], 2.0)/(constants[22]*constants[23])*(exp((states[0]-computed_constants[32])*constants[24]/(constants[22]*constants[23]))-1.0)/(exp(states[0]*constants[24]/(constants[22]*constants[23]))-1.0)*states[0] + algebraic[89] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[2], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) + algebraic[90] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[2], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 + algebraic[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) + algebraic[94] = algebraic[92] + algebraic[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 + algebraic[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 + algebraic[21] = computed_constants[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[103]) + algebraic[106] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[2], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[2], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) + algebraic[107] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[2], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) + algebraic[105] = 2.0/(algebraic[106]+algebraic[107]) + algebraic[104] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[2], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[2], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) + algebraic[110] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[2], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) + algebraic[111] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[2], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) + algebraic[109] = (1.2-0.2*computed_constants[0])/(algebraic[110]+algebraic[111]) if eq_func(constants[2], 1.0) else 1.0/(algebraic[110]+algebraic[111]) + algebraic[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) + algebraic[20] = computed_constants[112]*states[7]*states[6]*(states[0]-constants[119]) + algebraic[122] = 1068.0*exp((states[0]+26.3)/30.0) + algebraic[123] = 1068.0*exp(-(states[0]+26.3)/30.0) + algebraic[121] = 1.0/(algebraic[122]+algebraic[123]) + algebraic[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) + algebraic[126] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[2], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) + algebraic[127] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[2], 1.0) else 15.0*exp((states[0]+71.7)/15.38) + algebraic[125] = 1.0/(algebraic[126]+algebraic[127]) + algebraic[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) + algebraic[19] = computed_constants[128]*states[9]*states[8]*(states[0]-computed_constants[40]) + algebraic[18] = computed_constants[135]*states[8]*(states[0]-computed_constants[40]) + algebraic[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) + algebraic[143] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[2], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[2], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) + algebraic[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) + algebraic[145] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[2], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[2], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) + algebraic[153] = 0.6*states[11]+0.4*states[12] + algebraic[17] = computed_constants[146]*algebraic[153]*states[10]*(states[0]-computed_constants[40]) + algebraic[154] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[2], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) + algebraic[155] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[2], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) + algebraic[156] = algebraic[154] + algebraic[157] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[2], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) + algebraic[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) + algebraic[16] = computed_constants[160]*pow(states[13], 2.0)*(states[0]-computed_constants[80]) + algebraic[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) + algebraic[168] = 1.0*exp(-states[0]/45.0) + algebraic[15] = computed_constants[169]*states[14]*(states[0]-computed_constants[32]) if neq_func(constants[2], 2.0) else computed_constants[169]*states[14]*(states[0]-77.6) + algebraic[14] = computed_constants[176]*states[14]*(states[0]-computed_constants[40]) if neq_func(constants[2], 2.0) else computed_constants[176]*states[14]*(states[0]+102.0) + algebraic[183] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[2], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) + algebraic[184] = 1.0*exp((states[0]+75.13)/21.25) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index b7a5b4fd4..df6f7da7a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -72,53 +72,53 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - variables[4] = 1.0; - variables[5] = 0.0; - variables[7] = 0.3; - variables[9] = 120.0; - variables[15] = 36.0; + constants[4] = 1.0; + constants[5] = 0.0; + constants[7] = 0.3; + constants[9] = 120.0; + constants[15] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; - variables[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[0] = externalVariable(voi, states, rates, variables, 0); } void computeComputedConstants(double *constants, double *computedConstants) { - variables[6] = variables[5]-10.613; - variables[8] = variables[5]-115.0; - variables[14] = variables[5]+12.0; + computedConstants[6] = constants[5]-10.613; + computedConstants[8] = constants[5]-115.0; + computedConstants[14] = constants[5]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[0] = externalVariable(voi, states, rates, variables, 0); - variables[1] = variables[7]*(states[0]-variables[6]); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4]; - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2]; - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1]; - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; + algebraic[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[0] = externalVariable(voi, states, rates, variables, 0); - variables[1] = variables[7]*(states[0]-variables[6]); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); + algebraic[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 0b83a47b5..e287d4bc5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -74,49 +74,49 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - variables[4] = 1.0 - variables[5] = 0.0 - variables[7] = 0.3 - variables[9] = 120.0 - variables[15] = 36.0 + constants[4] = 1.0 + constants[5] = 0.0 + constants[7] = 0.3 + constants[9] = 120.0 + constants[15] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 - variables[0] = external_variable(voi, states, rates, variables, 0) + algebraic[0] = external_variable(voi, states, rates, variables, 0) def compute_computed_constants(constants, computed_constants): - variables[6] = variables[5]-10.613 - variables[8] = variables[5]-115.0 - variables[14] = variables[5]+12.0 + computed_constants[6] = constants[5]-10.613 + computed_constants[8] = constants[5]-115.0 + computed_constants[14] = constants[5]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[0] = external_variable(voi, states, rates, variables, 0) - variables[1] = variables[7]*(states[0]-variables[6]) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4] - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2] - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1] - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] + algebraic[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[0] = external_variable(voi, states, rates, variables, 0) - variables[1] = variables[7]*(states[0]-variables[6]) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) + algebraic[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 11925369a..0c24c18ef 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -72,11 +72,11 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[4] = 1.0; - variables[5] = 0.0; - variables[7] = 0.3; - variables[9] = 120.0; - variables[15] = 36.0; + constants[4] = 1.0; + constants[5] = 0.0; + constants[7] = 0.3; + constants[9] = 120.0; + constants[15] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; @@ -85,38 +85,38 @@ void initialiseVariables(double *states, double *rates, double *constants) void computeComputedConstants(double *constants, double *computedConstants) { - variables[6] = variables[5]-10.613; - variables[8] = variables[5]-115.0; - variables[14] = variables[5]+12.0; + computedConstants[6] = constants[5]-10.613; + computedConstants[8] = constants[5]-115.0; + computedConstants[14] = constants[5]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - variables[1] = variables[7]*(states[0]-variables[6]); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4]; - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2]; - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1]; - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; + algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[1] = variables[7]*(states[0]-variables[6]); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 122e1223d..bf291e2fb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -72,53 +72,53 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - variables[4] = 1.0; - variables[5] = 0.0; - variables[7] = 0.3; - variables[9] = 120.0; - variables[15] = 36.0; + constants[4] = 1.0; + constants[5] = 0.0; + constants[7] = 0.3; + constants[9] = 120.0; + constants[15] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; - variables[6] = externalVariable(voi, states, rates, variables, 6); + algebraic[6] = externalVariable(voi, states, rates, variables, 6); } void computeComputedConstants(double *constants, double *computedConstants) { - variables[8] = variables[5]-115.0; - variables[14] = variables[5]+12.0; + computedConstants[8] = constants[5]-115.0; + computedConstants[14] = constants[5]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - variables[6] = externalVariable(voi, states, rates, variables, 6); - variables[1] = variables[7]*(states[0]-variables[6]); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4]; - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2]; - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1]; - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; + algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraic[6] = externalVariable(voi, states, rates, variables, 6); + algebraic[1] = constants[7]*(states[0]-algebraic[6]); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[6] = externalVariable(voi, states, rates, variables, 6); - variables[1] = variables[7]*(states[0]-variables[6]); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); + algebraic[6] = externalVariable(voi, states, rates, variables, 6); + algebraic[1] = constants[7]*(states[0]-algebraic[6]); + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index a68331edb..2a928ef7f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -74,49 +74,49 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - variables[4] = 1.0 - variables[5] = 0.0 - variables[7] = 0.3 - variables[9] = 120.0 - variables[15] = 36.0 + constants[4] = 1.0 + constants[5] = 0.0 + constants[7] = 0.3 + constants[9] = 120.0 + constants[15] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 - variables[6] = external_variable(voi, states, rates, variables, 6) + algebraic[6] = external_variable(voi, states, rates, variables, 6) def compute_computed_constants(constants, computed_constants): - variables[8] = variables[5]-115.0 - variables[14] = variables[5]+12.0 + computed_constants[8] = constants[5]-115.0 + computed_constants[14] = constants[5]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - variables[6] = external_variable(voi, states, rates, variables, 6) - variables[1] = variables[7]*(states[0]-variables[6]) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4] - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2] - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1] - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] + algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic[6] = external_variable(voi, states, rates, variables, 6) + algebraic[1] = constants[7]*(states[0]-algebraic[6]) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[6] = external_variable(voi, states, rates, variables, 6) - variables[1] = variables[7]*(states[0]-variables[6]) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) + algebraic[6] = external_variable(voi, states, rates, variables, 6) + algebraic[1] = constants[7]*(states[0]-algebraic[6]) + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 074683762..f3d725514 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -72,53 +72,53 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - variables[5] = 0.0; - variables[7] = 0.3; - variables[9] = 120.0; - variables[15] = 36.0; + constants[5] = 0.0; + constants[7] = 0.3; + constants[9] = 120.0; + constants[15] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; - variables[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) { - variables[6] = variables[5]-10.613; - variables[8] = variables[5]-115.0; - variables[14] = variables[5]+12.0; + computedConstants[6] = constants[5]-10.613; + computedConstants[8] = constants[5]-115.0; + computedConstants[14] = constants[5]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - variables[4] = externalVariable(voi, states, rates, variables, 4); - variables[1] = variables[7]*(states[0]-variables[6]); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4]; - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2]; - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1]; - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; + algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraic[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4]; + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[1] = variables[7]*(states[0]-variables[6]); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); - variables[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index ea8e627d8..99304a266 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -74,49 +74,49 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - variables[5] = 0.0 - variables[7] = 0.3 - variables[9] = 120.0 - variables[15] = 36.0 + constants[5] = 0.0 + constants[7] = 0.3 + constants[9] = 120.0 + constants[15] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 - variables[4] = external_variable(voi, states, rates, variables, 4) + algebraic[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): - variables[6] = variables[5]-10.613 - variables[8] = variables[5]-115.0 - variables[14] = variables[5]+12.0 + computed_constants[6] = constants[5]-10.613 + computed_constants[8] = constants[5]-115.0 + computed_constants[14] = constants[5]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - variables[4] = external_variable(voi, states, rates, variables, 4) - variables[1] = variables[7]*(states[0]-variables[6]) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4] - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2] - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1] - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] + algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic[4] = external_variable(voi, states, rates, variables, 4) + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4] + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[1] = variables[7]*(states[0]-variables[6]) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) - variables[4] = external_variable(voi, states, rates, variables, 4) + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) + algebraic[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 3dd59ed73..79d7df082 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -87,9 +87,9 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[0] = u[0]; + algebraic[0] = u[0]; - f[0] = variables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; + f[0] = algebraic[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -97,11 +97,11 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[0]; + u[0] = algebraic[0]; nlaSolve(objectiveFunction0, u, 1, &rfi); - variables[0] = u[0]; + algebraic[0] = u[0]; } void objectiveFunction1(double *u, double *f, void *data) @@ -113,7 +113,7 @@ void objectiveFunction1(double *u, double *f, void *data) rates[0] = u[0]; - f[0] = rates[0]-(-(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4])-0.0; + f[0] = rates[0]-(-(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4])-0.0; } void findRoot1(double voi, double *states, double *rates, double *variables) @@ -135,9 +135,9 @@ void objectiveFunction2(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[6] = u[0]; + computedConstants[6] = u[0]; - f[0] = variables[6]-(variables[5]-10.613)-0.0; + f[0] = computedConstants[6]-(constants[5]-10.613)-0.0; } void findRoot2(double voi, double *states, double *rates, double *variables) @@ -145,11 +145,11 @@ void findRoot2(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[6]; + u[0] = algebraic[6]; nlaSolve(objectiveFunction2, u, 1, &rfi); - variables[6] = u[0]; + algebraic[6] = u[0]; } void objectiveFunction3(double *u, double *f, void *data) @@ -159,9 +159,9 @@ void objectiveFunction3(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[1] = u[0]; + algebraic[1] = u[0]; - f[0] = variables[1]-variables[7]*(states[0]-variables[6])-0.0; + f[0] = algebraic[1]-constants[7]*(states[0]-computedConstants[6])-0.0; } void findRoot3(double voi, double *states, double *rates, double *variables) @@ -169,11 +169,11 @@ void findRoot3(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[1]; + u[0] = algebraic[1]; nlaSolve(objectiveFunction3, u, 1, &rfi); - variables[1] = u[0]; + algebraic[1] = u[0]; } void objectiveFunction4(double *u, double *f, void *data) @@ -183,9 +183,9 @@ void objectiveFunction4(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[8] = u[0]; + computedConstants[8] = u[0]; - f[0] = variables[8]-(variables[5]-115.0)-0.0; + f[0] = computedConstants[8]-(constants[5]-115.0)-0.0; } void findRoot4(double voi, double *states, double *rates, double *variables) @@ -193,11 +193,11 @@ void findRoot4(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[8]; + u[0] = algebraic[8]; nlaSolve(objectiveFunction4, u, 1, &rfi); - variables[8] = u[0]; + algebraic[8] = u[0]; } void objectiveFunction5(double *u, double *f, void *data) @@ -207,9 +207,9 @@ void objectiveFunction5(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[3] = u[0]; + algebraic[3] = u[0]; - f[0] = variables[3]-variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8])-0.0; + f[0] = algebraic[3]-constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8])-0.0; } void findRoot5(double voi, double *states, double *rates, double *variables) @@ -217,11 +217,11 @@ void findRoot5(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[3]; + u[0] = algebraic[3]; nlaSolve(objectiveFunction5, u, 1, &rfi); - variables[3] = u[0]; + algebraic[3] = u[0]; } void objectiveFunction6(double *u, double *f, void *data) @@ -231,9 +231,9 @@ void objectiveFunction6(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[10] = u[0]; + algebraic[10] = u[0]; - f[0] = variables[10]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0; + f[0] = algebraic[10]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0; } void findRoot6(double voi, double *states, double *rates, double *variables) @@ -241,11 +241,11 @@ void findRoot6(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[10]; + u[0] = algebraic[10]; nlaSolve(objectiveFunction6, u, 1, &rfi); - variables[10] = u[0]; + algebraic[10] = u[0]; } void objectiveFunction7(double *u, double *f, void *data) @@ -255,9 +255,9 @@ void objectiveFunction7(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[11] = u[0]; + algebraic[11] = u[0]; - f[0] = variables[11]-4.0*exp(states[0]/18.0)-0.0; + f[0] = algebraic[11]-4.0*exp(states[0]/18.0)-0.0; } void findRoot7(double voi, double *states, double *rates, double *variables) @@ -265,11 +265,11 @@ void findRoot7(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[11]; + u[0] = algebraic[11]; nlaSolve(objectiveFunction7, u, 1, &rfi); - variables[11] = u[0]; + algebraic[11] = u[0]; } void objectiveFunction8(double *u, double *f, void *data) @@ -281,7 +281,7 @@ void objectiveFunction8(double *u, double *f, void *data) rates[2] = u[0]; - f[0] = rates[2]-(variables[10]*(1.0-states[2])-variables[11]*states[2])-0.0; + f[0] = rates[2]-(algebraic[10]*(1.0-states[2])-algebraic[11]*states[2])-0.0; } void findRoot8(double voi, double *states, double *rates, double *variables) @@ -303,9 +303,9 @@ void objectiveFunction9(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[12] = u[0]; + algebraic[12] = u[0]; - f[0] = variables[12]-0.07*exp(states[0]/20.0)-0.0; + f[0] = algebraic[12]-0.07*exp(states[0]/20.0)-0.0; } void findRoot9(double voi, double *states, double *rates, double *variables) @@ -313,11 +313,11 @@ void findRoot9(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[12]; + u[0] = algebraic[12]; nlaSolve(objectiveFunction9, u, 1, &rfi); - variables[12] = u[0]; + algebraic[12] = u[0]; } void objectiveFunction10(double *u, double *f, void *data) @@ -327,9 +327,9 @@ void objectiveFunction10(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[13] = u[0]; + algebraic[13] = u[0]; - f[0] = variables[13]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; + f[0] = algebraic[13]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; } void findRoot10(double voi, double *states, double *rates, double *variables) @@ -337,11 +337,11 @@ void findRoot10(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[13]; + u[0] = algebraic[13]; nlaSolve(objectiveFunction10, u, 1, &rfi); - variables[13] = u[0]; + algebraic[13] = u[0]; } void objectiveFunction11(double *u, double *f, void *data) @@ -353,7 +353,7 @@ void objectiveFunction11(double *u, double *f, void *data) rates[1] = u[0]; - f[0] = rates[1]-(variables[12]*(1.0-states[1])-variables[13]*states[1])-0.0; + f[0] = rates[1]-(algebraic[12]*(1.0-states[1])-algebraic[13]*states[1])-0.0; } void findRoot11(double voi, double *states, double *rates, double *variables) @@ -375,9 +375,9 @@ void objectiveFunction12(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[14] = u[0]; + computedConstants[14] = u[0]; - f[0] = variables[14]-(variables[5]+12.0)-0.0; + f[0] = computedConstants[14]-(constants[5]+12.0)-0.0; } void findRoot12(double voi, double *states, double *rates, double *variables) @@ -385,11 +385,11 @@ void findRoot12(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[14]; + u[0] = algebraic[14]; nlaSolve(objectiveFunction12, u, 1, &rfi); - variables[14] = u[0]; + algebraic[14] = u[0]; } void objectiveFunction13(double *u, double *f, void *data) @@ -399,9 +399,9 @@ void objectiveFunction13(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[2] = u[0]; + algebraic[2] = u[0]; - f[0] = variables[2]-variables[15]*pow(states[3], 4.0)*(states[0]-variables[14])-0.0; + f[0] = algebraic[2]-constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14])-0.0; } void findRoot13(double voi, double *states, double *rates, double *variables) @@ -409,11 +409,11 @@ void findRoot13(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[2]; + u[0] = algebraic[2]; nlaSolve(objectiveFunction13, u, 1, &rfi); - variables[2] = u[0]; + algebraic[2] = u[0]; } void objectiveFunction14(double *u, double *f, void *data) @@ -423,9 +423,9 @@ void objectiveFunction14(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[16] = u[0]; + algebraic[16] = u[0]; - f[0] = variables[16]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; + f[0] = algebraic[16]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; } void findRoot14(double voi, double *states, double *rates, double *variables) @@ -433,11 +433,11 @@ void findRoot14(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[16]; + u[0] = algebraic[16]; nlaSolve(objectiveFunction14, u, 1, &rfi); - variables[16] = u[0]; + algebraic[16] = u[0]; } void objectiveFunction15(double *u, double *f, void *data) @@ -447,9 +447,9 @@ void objectiveFunction15(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[17] = u[0]; + algebraic[17] = u[0]; - f[0] = variables[17]-0.125*exp(states[0]/80.0)-0.0; + f[0] = algebraic[17]-0.125*exp(states[0]/80.0)-0.0; } void findRoot15(double voi, double *states, double *rates, double *variables) @@ -457,11 +457,11 @@ void findRoot15(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[17]; + u[0] = algebraic[17]; nlaSolve(objectiveFunction15, u, 1, &rfi); - variables[17] = u[0]; + algebraic[17] = u[0]; } void objectiveFunction16(double *u, double *f, void *data) @@ -473,7 +473,7 @@ void objectiveFunction16(double *u, double *f, void *data) rates[3] = u[0]; - f[0] = rates[3]-(variables[16]*(1.0-states[3])-variables[17]*states[3])-0.0; + f[0] = rates[3]-(algebraic[16]*(1.0-states[3])-algebraic[17]*states[3])-0.0; } void findRoot16(double voi, double *states, double *rates, double *variables) @@ -490,24 +490,24 @@ void findRoot16(double voi, double *states, double *rates, double *variables) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 0.0; - variables[1] = 0.0; - variables[2] = 0.0; - variables[3] = 0.0; - variables[4] = 1.0; - variables[5] = 0.0; - variables[6] = 0.0; - variables[7] = 0.3; - variables[8] = 0.0; - variables[9] = 120.0; - variables[10] = 0.0; - variables[11] = 0.0; - variables[12] = 0.0; - variables[13] = 0.0; - variables[14] = 0.0; - variables[15] = 36.0; - variables[16] = 0.0; - variables[17] = 0.0; + algebraic[0] = 0.0; + algebraic[1] = 0.0; + algebraic[2] = 0.0; + algebraic[3] = 0.0; + constants[4] = 1.0; + constants[5] = 0.0; + computedConstants[6] = 0.0; + constants[7] = 0.3; + computedConstants[8] = 0.0; + constants[9] = 120.0; + algebraic[10] = 0.0; + algebraic[11] = 0.0; + algebraic[12] = 0.0; + algebraic[13] = 0.0; + computedConstants[14] = 0.0; + constants[15] = 36.0; + algebraic[16] = 0.0; + algebraic[17] = 0.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index b74a9e03c..068073cbd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -81,19 +81,19 @@ def objective_function_0(u, f, data): rates = data[2] variables = data[3] - variables[0] = u[0] + algebraic[0] = u[0] - f[0] = variables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 + f[0] = algebraic[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 def find_root_0(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[0] + u[0] = algebraic[0] u = nla_solve(objective_function_0, u, 1, [voi, states, rates, variables]) - variables[0] = u[0] + algebraic[0] = u[0] def objective_function_1(u, f, data): @@ -104,7 +104,7 @@ def objective_function_1(u, f, data): rates[0] = u[0] - f[0] = rates[0]-(-(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4])-0.0 + f[0] = rates[0]-(-(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4])-0.0 def find_root_1(voi, states, rates, variables): @@ -123,19 +123,19 @@ def objective_function_2(u, f, data): rates = data[2] variables = data[3] - variables[6] = u[0] + computed_constants[6] = u[0] - f[0] = variables[6]-(variables[5]-10.613)-0.0 + f[0] = computed_constants[6]-(constants[5]-10.613)-0.0 def find_root_2(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[6] + u[0] = algebraic[6] u = nla_solve(objective_function_2, u, 1, [voi, states, rates, variables]) - variables[6] = u[0] + algebraic[6] = u[0] def objective_function_3(u, f, data): @@ -144,19 +144,19 @@ def objective_function_3(u, f, data): rates = data[2] variables = data[3] - variables[1] = u[0] + algebraic[1] = u[0] - f[0] = variables[1]-variables[7]*(states[0]-variables[6])-0.0 + f[0] = algebraic[1]-constants[7]*(states[0]-computed_constants[6])-0.0 def find_root_3(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[1] + u[0] = algebraic[1] u = nla_solve(objective_function_3, u, 1, [voi, states, rates, variables]) - variables[1] = u[0] + algebraic[1] = u[0] def objective_function_4(u, f, data): @@ -165,19 +165,19 @@ def objective_function_4(u, f, data): rates = data[2] variables = data[3] - variables[8] = u[0] + computed_constants[8] = u[0] - f[0] = variables[8]-(variables[5]-115.0)-0.0 + f[0] = computed_constants[8]-(constants[5]-115.0)-0.0 def find_root_4(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[8] + u[0] = algebraic[8] u = nla_solve(objective_function_4, u, 1, [voi, states, rates, variables]) - variables[8] = u[0] + algebraic[8] = u[0] def objective_function_5(u, f, data): @@ -186,19 +186,19 @@ def objective_function_5(u, f, data): rates = data[2] variables = data[3] - variables[3] = u[0] + algebraic[3] = u[0] - f[0] = variables[3]-variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8])-0.0 + f[0] = algebraic[3]-constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8])-0.0 def find_root_5(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[3] + u[0] = algebraic[3] u = nla_solve(objective_function_5, u, 1, [voi, states, rates, variables]) - variables[3] = u[0] + algebraic[3] = u[0] def objective_function_6(u, f, data): @@ -207,19 +207,19 @@ def objective_function_6(u, f, data): rates = data[2] variables = data[3] - variables[10] = u[0] + algebraic[10] = u[0] - f[0] = variables[10]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0 + f[0] = algebraic[10]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0 def find_root_6(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[10] + u[0] = algebraic[10] u = nla_solve(objective_function_6, u, 1, [voi, states, rates, variables]) - variables[10] = u[0] + algebraic[10] = u[0] def objective_function_7(u, f, data): @@ -228,19 +228,19 @@ def objective_function_7(u, f, data): rates = data[2] variables = data[3] - variables[11] = u[0] + algebraic[11] = u[0] - f[0] = variables[11]-4.0*exp(states[0]/18.0)-0.0 + f[0] = algebraic[11]-4.0*exp(states[0]/18.0)-0.0 def find_root_7(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[11] + u[0] = algebraic[11] u = nla_solve(objective_function_7, u, 1, [voi, states, rates, variables]) - variables[11] = u[0] + algebraic[11] = u[0] def objective_function_8(u, f, data): @@ -251,7 +251,7 @@ def objective_function_8(u, f, data): rates[2] = u[0] - f[0] = rates[2]-(variables[10]*(1.0-states[2])-variables[11]*states[2])-0.0 + f[0] = rates[2]-(algebraic[10]*(1.0-states[2])-algebraic[11]*states[2])-0.0 def find_root_8(voi, states, rates, variables): @@ -270,19 +270,19 @@ def objective_function_9(u, f, data): rates = data[2] variables = data[3] - variables[12] = u[0] + algebraic[12] = u[0] - f[0] = variables[12]-0.07*exp(states[0]/20.0)-0.0 + f[0] = algebraic[12]-0.07*exp(states[0]/20.0)-0.0 def find_root_9(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[12] + u[0] = algebraic[12] u = nla_solve(objective_function_9, u, 1, [voi, states, rates, variables]) - variables[12] = u[0] + algebraic[12] = u[0] def objective_function_10(u, f, data): @@ -291,19 +291,19 @@ def objective_function_10(u, f, data): rates = data[2] variables = data[3] - variables[13] = u[0] + algebraic[13] = u[0] - f[0] = variables[13]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 + f[0] = algebraic[13]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 def find_root_10(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[13] + u[0] = algebraic[13] u = nla_solve(objective_function_10, u, 1, [voi, states, rates, variables]) - variables[13] = u[0] + algebraic[13] = u[0] def objective_function_11(u, f, data): @@ -314,7 +314,7 @@ def objective_function_11(u, f, data): rates[1] = u[0] - f[0] = rates[1]-(variables[12]*(1.0-states[1])-variables[13]*states[1])-0.0 + f[0] = rates[1]-(algebraic[12]*(1.0-states[1])-algebraic[13]*states[1])-0.0 def find_root_11(voi, states, rates, variables): @@ -333,19 +333,19 @@ def objective_function_12(u, f, data): rates = data[2] variables = data[3] - variables[14] = u[0] + computed_constants[14] = u[0] - f[0] = variables[14]-(variables[5]+12.0)-0.0 + f[0] = computed_constants[14]-(constants[5]+12.0)-0.0 def find_root_12(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[14] + u[0] = algebraic[14] u = nla_solve(objective_function_12, u, 1, [voi, states, rates, variables]) - variables[14] = u[0] + algebraic[14] = u[0] def objective_function_13(u, f, data): @@ -354,19 +354,19 @@ def objective_function_13(u, f, data): rates = data[2] variables = data[3] - variables[2] = u[0] + algebraic[2] = u[0] - f[0] = variables[2]-variables[15]*pow(states[3], 4.0)*(states[0]-variables[14])-0.0 + f[0] = algebraic[2]-constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14])-0.0 def find_root_13(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[2] + u[0] = algebraic[2] u = nla_solve(objective_function_13, u, 1, [voi, states, rates, variables]) - variables[2] = u[0] + algebraic[2] = u[0] def objective_function_14(u, f, data): @@ -375,19 +375,19 @@ def objective_function_14(u, f, data): rates = data[2] variables = data[3] - variables[16] = u[0] + algebraic[16] = u[0] - f[0] = variables[16]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 + f[0] = algebraic[16]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 def find_root_14(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[16] + u[0] = algebraic[16] u = nla_solve(objective_function_14, u, 1, [voi, states, rates, variables]) - variables[16] = u[0] + algebraic[16] = u[0] def objective_function_15(u, f, data): @@ -396,19 +396,19 @@ def objective_function_15(u, f, data): rates = data[2] variables = data[3] - variables[17] = u[0] + algebraic[17] = u[0] - f[0] = variables[17]-0.125*exp(states[0]/80.0)-0.0 + f[0] = algebraic[17]-0.125*exp(states[0]/80.0)-0.0 def find_root_15(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[17] + u[0] = algebraic[17] u = nla_solve(objective_function_15, u, 1, [voi, states, rates, variables]) - variables[17] = u[0] + algebraic[17] = u[0] def objective_function_16(u, f, data): @@ -419,7 +419,7 @@ def objective_function_16(u, f, data): rates[3] = u[0] - f[0] = rates[3]-(variables[16]*(1.0-states[3])-variables[17]*states[3])-0.0 + f[0] = rates[3]-(algebraic[16]*(1.0-states[3])-algebraic[17]*states[3])-0.0 def find_root_16(voi, states, rates, variables): @@ -433,24 +433,24 @@ def find_root_16(voi, states, rates, variables): def initialise_variables(states, rates, constants): - variables[0] = 0.0 - variables[1] = 0.0 - variables[2] = 0.0 - variables[3] = 0.0 - variables[4] = 1.0 - variables[5] = 0.0 - variables[6] = 0.0 - variables[7] = 0.3 - variables[8] = 0.0 - variables[9] = 120.0 - variables[10] = 0.0 - variables[11] = 0.0 - variables[12] = 0.0 - variables[13] = 0.0 - variables[14] = 0.0 - variables[15] = 36.0 - variables[16] = 0.0 - variables[17] = 0.0 + algebraic[0] = 0.0 + algebraic[1] = 0.0 + algebraic[2] = 0.0 + algebraic[3] = 0.0 + constants[4] = 1.0 + constants[5] = 0.0 + computed_constants[6] = 0.0 + constants[7] = 0.3 + computed_constants[8] = 0.0 + constants[9] = 120.0 + algebraic[10] = 0.0 + algebraic[11] = 0.0 + algebraic[12] = 0.0 + algebraic[13] = 0.0 + computed_constants[14] = 0.0 + constants[15] = 36.0 + algebraic[16] = 0.0 + algebraic[17] = 0.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index d71fcc410..9533f72f5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -72,54 +72,54 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - variables[4] = 1.0; - variables[5] = 0.0; - variables[7] = 0.3; - variables[9] = 120.0; - variables[15] = 36.0; + constants[4] = 1.0; + constants[5] = 0.0; + constants[7] = 0.3; + constants[9] = 120.0; + constants[15] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; - variables[17] = externalVariable(voi, states, rates, variables, 17); - variables[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[17] = externalVariable(voi, states, rates, variables, 17); + algebraic[0] = externalVariable(voi, states, rates, variables, 0); } void computeComputedConstants(double *constants, double *computedConstants) { - variables[6] = variables[5]-10.613; - variables[8] = variables[5]-115.0; - variables[14] = variables[5]+12.0; + computedConstants[6] = constants[5]-10.613; + computedConstants[8] = constants[5]-115.0; + computedConstants[14] = constants[5]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[17] = externalVariable(voi, states, rates, variables, 17); - variables[0] = externalVariable(voi, states, rates, variables, 0); - variables[1] = variables[7]*(states[0]-variables[6]); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4]; - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2]; - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1]; - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; + algebraic[17] = externalVariable(voi, states, rates, variables, 17); + algebraic[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[17] = externalVariable(voi, states, rates, variables, 17); - variables[0] = externalVariable(voi, states, rates, variables, 0); - variables[1] = variables[7]*(states[0]-variables[6]); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = externalVariable(voi, states, rates, variables, 17); + algebraic[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 4f026e071..381f0a24f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -74,50 +74,50 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - variables[4] = 1.0 - variables[5] = 0.0 - variables[7] = 0.3 - variables[9] = 120.0 - variables[15] = 36.0 + constants[4] = 1.0 + constants[5] = 0.0 + constants[7] = 0.3 + constants[9] = 120.0 + constants[15] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 - variables[17] = external_variable(voi, states, rates, variables, 17) - variables[0] = external_variable(voi, states, rates, variables, 0) + algebraic[17] = external_variable(voi, states, rates, variables, 17) + algebraic[0] = external_variable(voi, states, rates, variables, 0) def compute_computed_constants(constants, computed_constants): - variables[6] = variables[5]-10.613 - variables[8] = variables[5]-115.0 - variables[14] = variables[5]+12.0 + computed_constants[6] = constants[5]-10.613 + computed_constants[8] = constants[5]-115.0 + computed_constants[14] = constants[5]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[17] = external_variable(voi, states, rates, variables, 17) - variables[0] = external_variable(voi, states, rates, variables, 0) - variables[1] = variables[7]*(states[0]-variables[6]) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4] - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2] - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1] - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] + algebraic[17] = external_variable(voi, states, rates, variables, 17) + algebraic[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[17] = external_variable(voi, states, rates, variables, 17) - variables[0] = external_variable(voi, states, rates, variables, 0) - variables[1] = variables[7]*(states[0]-variables[6]) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = external_variable(voi, states, rates, variables, 17) + algebraic[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 35e65eb5b..4a61f2b74 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -72,16 +72,16 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - variables[4] = 1.0; - variables[7] = 0.3; - variables[9] = 120.0; - variables[15] = 36.0; + constants[4] = 1.0; + constants[7] = 0.3; + constants[9] = 120.0; + constants[15] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; - variables[14] = externalVariable(voi, states, rates, variables, 14); - variables[5] = externalVariable(voi, states, rates, variables, 5); + algebraic[14] = externalVariable(voi, states, rates, variables, 14); + algebraic[5] = externalVariable(voi, states, rates, variables, 5); } void computeComputedConstants(double *constants, double *computedConstants) @@ -90,39 +90,39 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - variables[14] = externalVariable(voi, states, rates, variables, 14); - variables[5] = externalVariable(voi, states, rates, variables, 5); - variables[6] = variables[5]-10.613; - variables[1] = variables[7]*(states[0]-variables[6]); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[8] = variables[5]-115.0; - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4]; - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2]; - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1]; - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; + algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraic[14] = externalVariable(voi, states, rates, variables, 14); + algebraic[5] = externalVariable(voi, states, rates, variables, 5); + algebraic[6] = algebraic[5]-10.613; + algebraic[1] = constants[7]*(states[0]-algebraic[6]); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-algebraic[14]); + algebraic[8] = algebraic[5]-115.0; + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[8]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[14] = externalVariable(voi, states, rates, variables, 14); - variables[5] = externalVariable(voi, states, rates, variables, 5); - variables[6] = variables[5]-10.613; - variables[1] = variables[7]*(states[0]-variables[6]); - variables[8] = variables[5]-115.0; - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); + algebraic[14] = externalVariable(voi, states, rates, variables, 14); + algebraic[5] = externalVariable(voi, states, rates, variables, 5); + algebraic[6] = algebraic[5]-10.613; + algebraic[1] = constants[7]*(states[0]-algebraic[6]); + algebraic[8] = algebraic[5]-115.0; + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[8]); + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-algebraic[14]); + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index fa9198906..53027ad4c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -74,16 +74,16 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - variables[4] = 1.0 - variables[7] = 0.3 - variables[9] = 120.0 - variables[15] = 36.0 + constants[4] = 1.0 + constants[7] = 0.3 + constants[9] = 120.0 + constants[15] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 - variables[14] = external_variable(voi, states, rates, variables, 14) - variables[5] = external_variable(voi, states, rates, variables, 5) + algebraic[14] = external_variable(voi, states, rates, variables, 14) + algebraic[5] = external_variable(voi, states, rates, variables, 5) def compute_computed_constants(constants, computed_constants): @@ -91,37 +91,37 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - variables[14] = external_variable(voi, states, rates, variables, 14) - variables[5] = external_variable(voi, states, rates, variables, 5) - variables[6] = variables[5]-10.613 - variables[1] = variables[7]*(states[0]-variables[6]) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[8] = variables[5]-115.0 - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4] - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2] - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1] - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] + algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic[14] = external_variable(voi, states, rates, variables, 14) + algebraic[5] = external_variable(voi, states, rates, variables, 5) + algebraic[6] = algebraic[5]-10.613 + algebraic[1] = constants[7]*(states[0]-algebraic[6]) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-algebraic[14]) + algebraic[8] = algebraic[5]-115.0 + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[8]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[14] = external_variable(voi, states, rates, variables, 14) - variables[5] = external_variable(voi, states, rates, variables, 5) - variables[6] = variables[5]-10.613 - variables[1] = variables[7]*(states[0]-variables[6]) - variables[8] = variables[5]-115.0 - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) + algebraic[14] = external_variable(voi, states, rates, variables, 14) + algebraic[5] = external_variable(voi, states, rates, variables, 5) + algebraic[6] = algebraic[5]-10.613 + algebraic[1] = constants[7]*(states[0]-algebraic[6]) + algebraic[8] = algebraic[5]-115.0 + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[8]) + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-algebraic[14]) + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index a5180f902..be516f51b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -72,55 +72,55 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - variables[5] = 0.0; - variables[7] = 0.3; - variables[15] = 36.0; + constants[5] = 0.0; + constants[7] = 0.3; + constants[15] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; - variables[9] = externalVariable(voi, states, rates, variables, 9); - variables[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[9] = externalVariable(voi, states, rates, variables, 9); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) { - variables[6] = variables[5]-10.613; - variables[8] = variables[5]-115.0; - variables[14] = variables[5]+12.0; + computedConstants[6] = constants[5]-10.613; + computedConstants[8] = constants[5]-115.0; + computedConstants[14] = constants[5]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - variables[9] = externalVariable(voi, states, rates, variables, 9); - variables[4] = externalVariable(voi, states, rates, variables, 4); - variables[1] = variables[7]*(states[0]-variables[6]); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4]; - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2]; - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1]; - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3]; + algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraic[9] = externalVariable(voi, states, rates, variables, 9); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[3] = algebraic[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4]; + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[1] = variables[7]*(states[0]-variables[6]); - variables[9] = externalVariable(voi, states, rates, variables, 9); - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]); - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[11] = 4.0*exp(states[0]/18.0); - variables[12] = 0.07*exp(states[0]/20.0); - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]); - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[17] = 0.125*exp(states[0]/80.0); - variables[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[9] = externalVariable(voi, states, rates, variables, 9); + algebraic[3] = algebraic[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[11] = 4.0*exp(states[0]/18.0); + algebraic[12] = 0.07*exp(states[0]/20.0); + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[17] = 0.125*exp(states[0]/80.0); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 71f9a4827..e518a203f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -74,51 +74,51 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - variables[5] = 0.0 - variables[7] = 0.3 - variables[15] = 36.0 + constants[5] = 0.0 + constants[7] = 0.3 + constants[15] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 - variables[9] = external_variable(voi, states, rates, variables, 9) - variables[4] = external_variable(voi, states, rates, variables, 4) + algebraic[9] = external_variable(voi, states, rates, variables, 9) + algebraic[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): - variables[6] = variables[5]-10.613 - variables[8] = variables[5]-115.0 - variables[14] = variables[5]+12.0 + computed_constants[6] = constants[5]-10.613 + computed_constants[8] = constants[5]-115.0 + computed_constants[14] = constants[5]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - variables[9] = external_variable(voi, states, rates, variables, 9) - variables[4] = external_variable(voi, states, rates, variables, 4) - variables[1] = variables[7]*(states[0]-variables[6]) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4] - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2] - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1] - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] + algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic[9] = external_variable(voi, states, rates, variables, 9) + algebraic[4] = external_variable(voi, states, rates, variables, 4) + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[3] = algebraic[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4] + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[1] = variables[7]*(states[0]-variables[6]) - variables[9] = external_variable(voi, states, rates, variables, 9) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) - variables[4] = external_variable(voi, states, rates, variables, 4) + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[9] = external_variable(voi, states, rates, variables, 9) + algebraic[3] = algebraic[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) + algebraic[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 0f7cdf505..a8baed030 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -72,43 +72,43 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - variables[5] = 1.0; - variables[6] = 0.0; - variables[8] = 0.3; - variables[10] = 120.0; - variables[17] = 36.0; + constants[5] = 1.0; + constants[6] = 0.0; + constants[8] = 0.3; + constants[10] = 120.0; + constants[17] = 36.0; states[0] = 0.6; states[1] = 0.325; - variables[1] = externalVariable(voi, states, rates, variables, 1); - variables[11] = externalVariable(voi, states, rates, variables, 11); + algebraic[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[11] = externalVariable(voi, states, rates, variables, 11); } void computeComputedConstants(double *constants, double *computedConstants) { - variables[7] = variables[6]-10.613; - variables[9] = variables[6]-115.0; - variables[16] = variables[6]+12.0; + computedConstants[7] = constants[6]-10.613; + computedConstants[9] = constants[6]-115.0; + computedConstants[16] = constants[6]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[1] = externalVariable(voi, states, rates, variables, 1); - variables[14] = 0.07*exp(variables[1]/20.0); - variables[15] = 1.0/(exp((variables[1]+30.0)/10.0)+1.0); - rates[0] = variables[14]*(1.0-states[0])-variables[15]*states[0]; - variables[18] = 0.01*(variables[1]+10.0)/(exp((variables[1]+10.0)/10.0)-1.0); - variables[19] = 0.125*exp(variables[1]/80.0); - rates[1] = variables[18]*(1.0-states[1])-variables[19]*states[1]; + algebraic[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[14] = 0.07*exp(algebraic[1]/20.0); + algebraic[15] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0); + rates[0] = algebraic[14]*(1.0-states[0])-algebraic[15]*states[0]; + algebraic[18] = 0.01*(algebraic[1]+10.0)/(exp((algebraic[1]+10.0)/10.0)-1.0); + algebraic[19] = 0.125*exp(algebraic[1]/80.0); + rates[1] = algebraic[18]*(1.0-states[1])-algebraic[19]*states[1]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - variables[1] = externalVariable(voi, states, rates, variables, 1); - variables[2] = variables[8]*(variables[1]-variables[7]); - variables[11] = externalVariable(voi, states, rates, variables, 11); - variables[4] = variables[10]*pow(variables[11], 3.0)*states[0]*(variables[1]-variables[9]); - variables[12] = 0.1*(variables[1]+25.0)/(exp((variables[1]+25.0)/10.0)-1.0); - variables[13] = 4.0*exp(variables[1]/18.0); - variables[3] = variables[17]*pow(states[1], 4.0)*(variables[1]-variables[16]); + algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraic[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[2] = constants[8]*(algebraic[1]-computedConstants[7]); + algebraic[11] = externalVariable(voi, states, rates, variables, 11); + algebraic[4] = constants[10]*pow(algebraic[11], 3.0)*states[0]*(algebraic[1]-computedConstants[9]); + algebraic[12] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0); + algebraic[13] = 4.0*exp(algebraic[1]/18.0); + algebraic[3] = constants[17]*pow(states[1], 4.0)*(algebraic[1]-computedConstants[16]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 16326c27d..914194e7f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -74,39 +74,39 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - variables[5] = 1.0 - variables[6] = 0.0 - variables[8] = 0.3 - variables[10] = 120.0 - variables[17] = 36.0 + constants[5] = 1.0 + constants[6] = 0.0 + constants[8] = 0.3 + constants[10] = 120.0 + constants[17] = 36.0 states[0] = 0.6 states[1] = 0.325 - variables[1] = external_variable(voi, states, rates, variables, 1) - variables[11] = external_variable(voi, states, rates, variables, 11) + algebraic[1] = external_variable(voi, states, rates, variables, 1) + algebraic[11] = external_variable(voi, states, rates, variables, 11) def compute_computed_constants(constants, computed_constants): - variables[7] = variables[6]-10.613 - variables[9] = variables[6]-115.0 - variables[16] = variables[6]+12.0 + computed_constants[7] = constants[6]-10.613 + computed_constants[9] = constants[6]-115.0 + computed_constants[16] = constants[6]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[1] = external_variable(voi, states, rates, variables, 1) - variables[14] = 0.07*exp(variables[1]/20.0) - variables[15] = 1.0/(exp((variables[1]+30.0)/10.0)+1.0) - rates[0] = variables[14]*(1.0-states[0])-variables[15]*states[0] - variables[18] = 0.01*(variables[1]+10.0)/(exp((variables[1]+10.0)/10.0)-1.0) - variables[19] = 0.125*exp(variables[1]/80.0) - rates[1] = variables[18]*(1.0-states[1])-variables[19]*states[1] + algebraic[1] = external_variable(voi, states, rates, variables, 1) + algebraic[14] = 0.07*exp(algebraic[1]/20.0) + algebraic[15] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0) + rates[0] = algebraic[14]*(1.0-states[0])-algebraic[15]*states[0] + algebraic[18] = 0.01*(algebraic[1]+10.0)/(exp((algebraic[1]+10.0)/10.0)-1.0) + algebraic[19] = 0.125*exp(algebraic[1]/80.0) + rates[1] = algebraic[18]*(1.0-states[1])-algebraic[19]*states[1] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - variables[1] = external_variable(voi, states, rates, variables, 1) - variables[2] = variables[8]*(variables[1]-variables[7]) - variables[11] = external_variable(voi, states, rates, variables, 11) - variables[4] = variables[10]*pow(variables[11], 3.0)*states[0]*(variables[1]-variables[9]) - variables[12] = 0.1*(variables[1]+25.0)/(exp((variables[1]+25.0)/10.0)-1.0) - variables[13] = 4.0*exp(variables[1]/18.0) - variables[3] = variables[17]*pow(states[1], 4.0)*(variables[1]-variables[16]) + algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic[1] = external_variable(voi, states, rates, variables, 1) + algebraic[2] = constants[8]*(algebraic[1]-computed_constants[7]) + algebraic[11] = external_variable(voi, states, rates, variables, 11) + algebraic[4] = constants[10]*pow(algebraic[11], 3.0)*states[0]*(algebraic[1]-computed_constants[9]) + algebraic[12] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0) + algebraic[13] = 4.0*exp(algebraic[1]/18.0) + algebraic[3] = constants[17]*pow(states[1], 4.0)*(algebraic[1]-computed_constants[16]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 4deb76e68..b21ab1d04 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -72,46 +72,46 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - variables[5] = 1.0; - variables[6] = 0.0; - variables[8] = 0.3; - variables[10] = 120.0; - variables[16] = 36.0; + constants[5] = 1.0; + constants[6] = 0.0; + constants[8] = 0.3; + constants[10] = 120.0; + constants[16] = 36.0; states[0] = 0.6; states[1] = 0.05; states[2] = 0.325; - variables[1] = externalVariable(voi, states, rates, variables, 1); - variables[17] = externalVariable(voi, states, rates, variables, 17); - variables[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[17] = externalVariable(voi, states, rates, variables, 17); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) { - variables[7] = variables[6]-10.613; - variables[9] = variables[6]-115.0; - variables[15] = variables[6]+12.0; + computedConstants[7] = constants[6]-10.613; + computedConstants[9] = constants[6]-115.0; + computedConstants[15] = constants[6]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[1] = externalVariable(voi, states, rates, variables, 1); - variables[11] = 0.1*(variables[1]+25.0)/(exp((variables[1]+25.0)/10.0)-1.0); - variables[12] = 4.0*exp(variables[1]/18.0); - rates[1] = variables[11]*(1.0-states[1])-variables[12]*states[1]; - variables[13] = 0.07*exp(variables[1]/20.0); - variables[14] = 1.0/(exp((variables[1]+30.0)/10.0)+1.0); - rates[0] = variables[13]*(1.0-states[0])-variables[14]*states[0]; - variables[17] = externalVariable(voi, states, rates, variables, 17); - variables[18] = 0.125*exp(variables[1]/80.0); - rates[2] = variables[17]*(1.0-states[2])-variables[18]*states[2]; + algebraic[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[11] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0); + algebraic[12] = 4.0*exp(algebraic[1]/18.0); + rates[1] = algebraic[11]*(1.0-states[1])-algebraic[12]*states[1]; + algebraic[13] = 0.07*exp(algebraic[1]/20.0); + algebraic[14] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0); + rates[0] = algebraic[13]*(1.0-states[0])-algebraic[14]*states[0]; + algebraic[17] = externalVariable(voi, states, rates, variables, 17); + algebraic[18] = 0.125*exp(algebraic[1]/80.0); + rates[2] = algebraic[17]*(1.0-states[2])-algebraic[18]*states[2]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - variables[1] = externalVariable(voi, states, rates, variables, 1); - variables[2] = variables[8]*(variables[1]-variables[7]); - variables[17] = externalVariable(voi, states, rates, variables, 17); - variables[4] = externalVariable(voi, states, rates, variables, 4); - variables[3] = variables[16]*pow(states[2], 4.0)*(variables[1]-variables[15]); + algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraic[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[2] = constants[8]*(algebraic[1]-computedConstants[7]); + algebraic[17] = externalVariable(voi, states, rates, variables, 17); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[3] = constants[16]*pow(states[2], 4.0)*(algebraic[1]-computedConstants[15]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 89c02e24c..d64291b4a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -74,42 +74,42 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - variables[5] = 1.0 - variables[6] = 0.0 - variables[8] = 0.3 - variables[10] = 120.0 - variables[16] = 36.0 + constants[5] = 1.0 + constants[6] = 0.0 + constants[8] = 0.3 + constants[10] = 120.0 + constants[16] = 36.0 states[0] = 0.6 states[1] = 0.05 states[2] = 0.325 - variables[1] = external_variable(voi, states, rates, variables, 1) - variables[17] = external_variable(voi, states, rates, variables, 17) - variables[4] = external_variable(voi, states, rates, variables, 4) + algebraic[1] = external_variable(voi, states, rates, variables, 1) + algebraic[17] = external_variable(voi, states, rates, variables, 17) + algebraic[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): - variables[7] = variables[6]-10.613 - variables[9] = variables[6]-115.0 - variables[15] = variables[6]+12.0 + computed_constants[7] = constants[6]-10.613 + computed_constants[9] = constants[6]-115.0 + computed_constants[15] = constants[6]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[1] = external_variable(voi, states, rates, variables, 1) - variables[11] = 0.1*(variables[1]+25.0)/(exp((variables[1]+25.0)/10.0)-1.0) - variables[12] = 4.0*exp(variables[1]/18.0) - rates[1] = variables[11]*(1.0-states[1])-variables[12]*states[1] - variables[13] = 0.07*exp(variables[1]/20.0) - variables[14] = 1.0/(exp((variables[1]+30.0)/10.0)+1.0) - rates[0] = variables[13]*(1.0-states[0])-variables[14]*states[0] - variables[17] = external_variable(voi, states, rates, variables, 17) - variables[18] = 0.125*exp(variables[1]/80.0) - rates[2] = variables[17]*(1.0-states[2])-variables[18]*states[2] + algebraic[1] = external_variable(voi, states, rates, variables, 1) + algebraic[11] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0) + algebraic[12] = 4.0*exp(algebraic[1]/18.0) + rates[1] = algebraic[11]*(1.0-states[1])-algebraic[12]*states[1] + algebraic[13] = 0.07*exp(algebraic[1]/20.0) + algebraic[14] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0) + rates[0] = algebraic[13]*(1.0-states[0])-algebraic[14]*states[0] + algebraic[17] = external_variable(voi, states, rates, variables, 17) + algebraic[18] = 0.125*exp(algebraic[1]/80.0) + rates[2] = algebraic[17]*(1.0-states[2])-algebraic[18]*states[2] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - variables[1] = external_variable(voi, states, rates, variables, 1) - variables[2] = variables[8]*(variables[1]-variables[7]) - variables[17] = external_variable(voi, states, rates, variables, 17) - variables[4] = external_variable(voi, states, rates, variables, 4) - variables[3] = variables[16]*pow(states[2], 4.0)*(variables[1]-variables[15]) + algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic[1] = external_variable(voi, states, rates, variables, 1) + algebraic[2] = constants[8]*(algebraic[1]-computed_constants[7]) + algebraic[17] = external_variable(voi, states, rates, variables, 17) + algebraic[4] = external_variable(voi, states, rates, variables, 4) + algebraic[3] = constants[16]*pow(states[2], 4.0)*(algebraic[1]-computed_constants[15]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index a1d5201a6..87eb31f08 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -73,11 +73,11 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[4] = 1.0 - variables[5] = 0.0 - variables[7] = 0.3 - variables[9] = 120.0 - variables[15] = 36.0 + constants[4] = 1.0 + constants[5] = 0.0 + constants[7] = 0.3 + constants[9] = 120.0 + constants[15] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -85,35 +85,35 @@ def initialise_variables(states, rates, constants): def compute_computed_constants(constants, computed_constants): - variables[6] = variables[5]-10.613 - variables[8] = variables[5]-115.0 - variables[14] = variables[5]+12.0 + computed_constants[6] = constants[5]-10.613 + computed_constants[8] = constants[5]-115.0 + computed_constants[14] = constants[5]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - variables[1] = variables[7]*(states[0]-variables[6]) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4] - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - rates[2] = variables[10]*(1.0-states[2])-variables[11]*states[2] - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = variables[12]*(1.0-states[1])-variables[13]*states[1] - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) - rates[3] = variables[16]*(1.0-states[3])-variables[17]*states[3] + algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[1] = variables[7]*(states[0]-variables[6]) - variables[3] = variables[9]*pow(states[2], 3.0)*states[1]*(states[0]-variables[8]) - variables[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[11] = 4.0*exp(states[0]/18.0) - variables[12] = 0.07*exp(states[0]/20.0) - variables[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - variables[2] = variables[15]*pow(states[3], 4.0)*(states[0]-variables[14]) - variables[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[17] = 0.125*exp(states[0]/80.0) + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[11] = 4.0*exp(states[0]/18.0) + algebraic[12] = 0.07*exp(states[0]/20.0) + algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) + algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[17] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index b042ee21e..083b39125 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -72,50 +72,50 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - variables[4] = 1.0; - variables[5] = 0.0; - variables[7] = 0.3; - variables[9] = 120.0; - variables[16] = 36.0; + constants[4] = 1.0; + constants[5] = 0.0; + constants[7] = 0.3; + constants[9] = 120.0; + constants[16] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.325; - variables[10] = externalVariable(voi, states, rates, variables, 10); + algebraic[10] = externalVariable(voi, states, rates, variables, 10); } void computeComputedConstants(double *constants, double *computedConstants) { - variables[6] = variables[5]-10.613; - variables[8] = variables[5]-115.0; - variables[15] = variables[5]+12.0; + computedConstants[6] = constants[5]-10.613; + computedConstants[8] = constants[5]-115.0; + computedConstants[15] = constants[5]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - variables[1] = variables[7]*(states[0]-variables[6]); - variables[2] = variables[16]*pow(states[2], 4.0)*(states[0]-variables[15]); - variables[10] = externalVariable(voi, states, rates, variables, 10); - variables[3] = variables[9]*pow(variables[10], 3.0)*states[1]*(states[0]-variables[8]); - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4]; - variables[13] = 0.07*exp(states[0]/20.0); - variables[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = variables[13]*(1.0-states[1])-variables[14]*states[1]; - variables[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[18] = 0.125*exp(states[0]/80.0); - rates[2] = variables[17]*(1.0-states[2])-variables[18]*states[2]; + algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[2] = constants[16]*pow(states[2], 4.0)*(states[0]-computedConstants[15]); + algebraic[10] = externalVariable(voi, states, rates, variables, 10); + algebraic[3] = constants[9]*pow(algebraic[10], 3.0)*states[1]*(states[0]-computedConstants[8]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; + algebraic[13] = 0.07*exp(states[0]/20.0); + algebraic[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[13]*(1.0-states[1])-algebraic[14]*states[1]; + algebraic[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[18] = 0.125*exp(states[0]/80.0); + rates[2] = algebraic[17]*(1.0-states[2])-algebraic[18]*states[2]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[1] = variables[7]*(states[0]-variables[6]); - variables[10] = externalVariable(voi, states, rates, variables, 10); - variables[3] = variables[9]*pow(variables[10], 3.0)*states[1]*(states[0]-variables[8]); - variables[11] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - variables[12] = 4.0*exp(states[0]/18.0); - variables[13] = 0.07*exp(states[0]/20.0); - variables[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - variables[2] = variables[16]*pow(states[2], 4.0)*(states[0]-variables[15]); - variables[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - variables[18] = 0.125*exp(states[0]/80.0); + algebraic[1] = constants[7]*(states[0]-computedConstants[6]); + algebraic[10] = externalVariable(voi, states, rates, variables, 10); + algebraic[3] = constants[9]*pow(algebraic[10], 3.0)*states[1]*(states[0]-computedConstants[8]); + algebraic[11] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[12] = 4.0*exp(states[0]/18.0); + algebraic[13] = 0.07*exp(states[0]/20.0); + algebraic[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[16]*pow(states[2], 4.0)*(states[0]-computedConstants[15]); + algebraic[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[18] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 39debf9ca..bee8d59e4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -74,46 +74,46 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - variables[4] = 1.0 - variables[5] = 0.0 - variables[7] = 0.3 - variables[9] = 120.0 - variables[16] = 36.0 + constants[4] = 1.0 + constants[5] = 0.0 + constants[7] = 0.3 + constants[9] = 120.0 + constants[16] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.325 - variables[10] = external_variable(voi, states, rates, variables, 10) + algebraic[10] = external_variable(voi, states, rates, variables, 10) def compute_computed_constants(constants, computed_constants): - variables[6] = variables[5]-10.613 - variables[8] = variables[5]-115.0 - variables[15] = variables[5]+12.0 + computed_constants[6] = constants[5]-10.613 + computed_constants[8] = constants[5]-115.0 + computed_constants[15] = constants[5]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - variables[1] = variables[7]*(states[0]-variables[6]) - variables[2] = variables[16]*pow(states[2], 4.0)*(states[0]-variables[15]) - variables[10] = external_variable(voi, states, rates, variables, 10) - variables[3] = variables[9]*pow(variables[10], 3.0)*states[1]*(states[0]-variables[8]) - rates[0] = -(-variables[0]+variables[3]+variables[2]+variables[1])/variables[4] - variables[13] = 0.07*exp(states[0]/20.0) - variables[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = variables[13]*(1.0-states[1])-variables[14]*states[1] - variables[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[18] = 0.125*exp(states[0]/80.0) - rates[2] = variables[17]*(1.0-states[2])-variables[18]*states[2] + algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[2] = constants[16]*pow(states[2], 4.0)*(states[0]-computed_constants[15]) + algebraic[10] = external_variable(voi, states, rates, variables, 10) + algebraic[3] = constants[9]*pow(algebraic[10], 3.0)*states[1]*(states[0]-computed_constants[8]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] + algebraic[13] = 0.07*exp(states[0]/20.0) + algebraic[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[13]*(1.0-states[1])-algebraic[14]*states[1] + algebraic[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[18] = 0.125*exp(states[0]/80.0) + rates[2] = algebraic[17]*(1.0-states[2])-algebraic[18]*states[2] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - variables[1] = variables[7]*(states[0]-variables[6]) - variables[10] = external_variable(voi, states, rates, variables, 10) - variables[3] = variables[9]*pow(variables[10], 3.0)*states[1]*(states[0]-variables[8]) - variables[11] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - variables[12] = 4.0*exp(states[0]/18.0) - variables[13] = 0.07*exp(states[0]/20.0) - variables[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - variables[2] = variables[16]*pow(states[2], 4.0)*(states[0]-variables[15]) - variables[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - variables[18] = 0.125*exp(states[0]/80.0) + algebraic[1] = constants[7]*(states[0]-computed_constants[6]) + algebraic[10] = external_variable(voi, states, rates, variables, 10) + algebraic[3] = constants[9]*pow(algebraic[10], 3.0)*states[1]*(states[0]-computed_constants[8]) + algebraic[11] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[12] = 4.0*exp(states[0]/18.0) + algebraic[13] = 0.07*exp(states[0]/20.0) + algebraic[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[16]*pow(states[2], 4.0)*(states[0]-computed_constants[15]) + algebraic[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[18] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 8edc882e1..e8a180474 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -71,11 +71,11 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[3] = 12.0; - variables[4] = 0.075; - variables[5] = -60.0; - variables[7] = 400.0; - variables[8] = 40.0; + constants[3] = 12.0; + constants[4] = 0.075; + constants[5] = -60.0; + constants[7] = 400.0; + constants[8] = 40.0; states[0] = -87.0; states[1] = 0.01; states[2] = 0.8; @@ -88,36 +88,36 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[6] = pow(states[1], 3.0)*states[2]*variables[7]; - variables[0] = (variables[6]+0.14)*(states[0]-variables[8]); - variables[1] = variables[4]*(states[0]-variables[5]); - variables[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); - variables[14] = 1.2*pow(states[3], 4.0); - variables[2] = (variables[13]+variables[14])*(states[0]+100.0); - rates[0] = -(variables[0]+variables[2]+variables[1])/variables[3]; - variables[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); - variables[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); - rates[1] = variables[9]*(1.0-states[1])-variables[10]*states[1]; - variables[11] = 0.17*exp((-states[0]-90.0)/20.0); - variables[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); - rates[2] = variables[11]*(1.0-states[2])-variables[12]*states[2]; - variables[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); - variables[16] = 0.002*exp((-states[0]-90.0)/80.0); - rates[3] = variables[15]*(1.0-states[3])-variables[16]*states[3]; + algebraic[6] = pow(states[1], 3.0)*states[2]*constants[7]; + algebraic[0] = (algebraic[6]+0.14)*(states[0]-constants[8]); + algebraic[1] = constants[4]*(states[0]-constants[5]); + algebraic[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); + algebraic[14] = 1.2*pow(states[3], 4.0); + algebraic[2] = (algebraic[13]+algebraic[14])*(states[0]+100.0); + rates[0] = -(algebraic[0]+algebraic[2]+algebraic[1])/constants[3]; + algebraic[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); + algebraic[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); + rates[1] = algebraic[9]*(1.0-states[1])-algebraic[10]*states[1]; + algebraic[11] = 0.17*exp((-states[0]-90.0)/20.0); + algebraic[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); + rates[2] = algebraic[11]*(1.0-states[2])-algebraic[12]*states[2]; + algebraic[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); + algebraic[16] = 0.002*exp((-states[0]-90.0)/80.0); + rates[3] = algebraic[15]*(1.0-states[3])-algebraic[16]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[1] = variables[4]*(states[0]-variables[5]); - variables[6] = pow(states[1], 3.0)*states[2]*variables[7]; - variables[0] = (variables[6]+0.14)*(states[0]-variables[8]); - variables[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); - variables[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); - variables[11] = 0.17*exp((-states[0]-90.0)/20.0); - variables[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); - variables[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); - variables[14] = 1.2*pow(states[3], 4.0); - variables[2] = (variables[13]+variables[14])*(states[0]+100.0); - variables[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); - variables[16] = 0.002*exp((-states[0]-90.0)/80.0); + algebraic[1] = constants[4]*(states[0]-constants[5]); + algebraic[6] = pow(states[1], 3.0)*states[2]*constants[7]; + algebraic[0] = (algebraic[6]+0.14)*(states[0]-constants[8]); + algebraic[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); + algebraic[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); + algebraic[11] = 0.17*exp((-states[0]-90.0)/20.0); + algebraic[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); + algebraic[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); + algebraic[14] = 1.2*pow(states[3], 4.0); + algebraic[2] = (algebraic[13]+algebraic[14])*(states[0]+100.0); + algebraic[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); + algebraic[16] = 0.002*exp((-states[0]-90.0)/80.0); } diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 878cc8960..d9672b95f 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -60,11 +60,11 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[3] = 12.0 - variables[4] = 0.075 - variables[5] = -60.0 - variables[7] = 400.0 - variables[8] = 40.0 + constants[3] = 12.0 + constants[4] = 0.075 + constants[5] = -60.0 + constants[7] = 400.0 + constants[8] = 40.0 states[0] = -87.0 states[1] = 0.01 states[2] = 0.8 @@ -76,34 +76,34 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - variables[6] = pow(states[1], 3.0)*states[2]*variables[7] - variables[0] = (variables[6]+0.14)*(states[0]-variables[8]) - variables[1] = variables[4]*(states[0]-variables[5]) - variables[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) - variables[14] = 1.2*pow(states[3], 4.0) - variables[2] = (variables[13]+variables[14])*(states[0]+100.0) - rates[0] = -(variables[0]+variables[2]+variables[1])/variables[3] - variables[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) - variables[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) - rates[1] = variables[9]*(1.0-states[1])-variables[10]*states[1] - variables[11] = 0.17*exp((-states[0]-90.0)/20.0) - variables[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) - rates[2] = variables[11]*(1.0-states[2])-variables[12]*states[2] - variables[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) - variables[16] = 0.002*exp((-states[0]-90.0)/80.0) - rates[3] = variables[15]*(1.0-states[3])-variables[16]*states[3] + algebraic[6] = pow(states[1], 3.0)*states[2]*constants[7] + algebraic[0] = (algebraic[6]+0.14)*(states[0]-constants[8]) + algebraic[1] = constants[4]*(states[0]-constants[5]) + algebraic[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) + algebraic[14] = 1.2*pow(states[3], 4.0) + algebraic[2] = (algebraic[13]+algebraic[14])*(states[0]+100.0) + rates[0] = -(algebraic[0]+algebraic[2]+algebraic[1])/constants[3] + algebraic[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) + algebraic[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) + rates[1] = algebraic[9]*(1.0-states[1])-algebraic[10]*states[1] + algebraic[11] = 0.17*exp((-states[0]-90.0)/20.0) + algebraic[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) + rates[2] = algebraic[11]*(1.0-states[2])-algebraic[12]*states[2] + algebraic[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) + algebraic[16] = 0.002*exp((-states[0]-90.0)/80.0) + rates[3] = algebraic[15]*(1.0-states[3])-algebraic[16]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[1] = variables[4]*(states[0]-variables[5]) - variables[6] = pow(states[1], 3.0)*states[2]*variables[7] - variables[0] = (variables[6]+0.14)*(states[0]-variables[8]) - variables[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) - variables[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) - variables[11] = 0.17*exp((-states[0]-90.0)/20.0) - variables[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) - variables[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) - variables[14] = 1.2*pow(states[3], 4.0) - variables[2] = (variables[13]+variables[14])*(states[0]+100.0) - variables[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) - variables[16] = 0.002*exp((-states[0]-90.0)/80.0) + algebraic[1] = constants[4]*(states[0]-constants[5]) + algebraic[6] = pow(states[1], 3.0)*states[2]*constants[7] + algebraic[0] = (algebraic[6]+0.14)*(states[0]-constants[8]) + algebraic[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) + algebraic[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) + algebraic[11] = 0.17*exp((-states[0]-90.0)/20.0) + algebraic[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) + algebraic[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) + algebraic[14] = 1.2*pow(states[3], 4.0) + algebraic[2] = (algebraic[13]+algebraic[14])*(states[0]+100.0) + algebraic[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) + algebraic[16] = 0.002*exp((-states[0]-90.0)/80.0) diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 741fc1a1e..1bf89a3b8 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -52,7 +52,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 1.0; + computedConstants[0] = 1.0; states[0] = 1.0; } @@ -62,7 +62,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = variables[0]; + rates[0] = computedConstants[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 865bb0a91..e60d2476d 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -41,7 +41,7 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 1.0 + computed_constants[0] = 1.0 states[0] = 1.0 @@ -50,7 +50,7 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = variables[0] + rates[0] = computed_constants[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 2bc00c84f..cf371f670 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -52,7 +52,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 1.0; + computedConstants[0] = 1.0; states[0] = 1.0; } @@ -62,7 +62,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = variables[0]; + rates[0] = computedConstants[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 34f7dfbc5..847ad0446 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -41,7 +41,7 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 1.0 + computed_constants[0] = 1.0 states[0] = 1.0 @@ -50,7 +50,7 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = variables[0] + rates[0] = computed_constants[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index 65d922d8b..da29f52f6 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -52,7 +52,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 1.0; + constants[0] = 1.0; states[0] = 1.0; } @@ -62,7 +62,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = variables[0]; + rates[0] = constants[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index e2df2355f..351e628e4 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -41,7 +41,7 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 1.0 + constants[0] = 1.0 states[0] = 1.0 @@ -50,7 +50,7 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = variables[0] + rates[0] = constants[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index 8ea505b7f..9f18d3d5e 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -52,7 +52,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 1.0; + constants[0] = 1.0; states[0] = 1.0; } @@ -62,7 +62,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = variables[0]; + rates[0] = constants[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 939cc09a0..0ed240fa5 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -41,7 +41,7 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 1.0 + constants[0] = 1.0 states[0] = 1.0 @@ -50,7 +50,7 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = variables[0] + rates[0] = constants[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index bab99e785..89cfc22b7 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -53,7 +53,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 1.0; + constants[0] = 1.0; states[0] = -2.0; states[1] = 0.0; } @@ -65,7 +65,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = states[1]*1.0; - rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0; + rates[1] = (constants[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 50498a2ba..34b35116b 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -42,7 +42,7 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 1.0 + constants[0] = 1.0 states[0] = -2.0 states[1] = 0.0 @@ -53,7 +53,7 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = states[1]*1.0 - rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 + rates[1] = (constants[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 def compute_variables(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index c5e7e02a6..00d0e6e7a 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -53,7 +53,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 1.0; + constants[0] = 1.0; states[0] = -2.0; states[1] = 0.0; } @@ -65,7 +65,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = states[1]*1.0; - rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0; + rates[1] = (constants[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index d5b1bf1b9..59377dde9 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -42,7 +42,7 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 1.0 + constants[0] = 1.0 states[0] = -2.0 states[1] = 0.0 @@ -53,7 +53,7 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = states[1]*1.0 - rates[1] = (variables[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 + rates[1] = (constants[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 def compute_variables(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 967c84456..b3c86f5bb 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -53,7 +53,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 1.0; + constants[0] = 1.0; states[0] = 1.0; states[1] = 1.0; } @@ -65,7 +65,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = 1.0; - rates[1] = variables[0]; + rates[1] = constants[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 8ac8235fc..93bd5d2fd 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -42,7 +42,7 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 1.0 + constants[0] = 1.0 states[0] = 1.0 states[1] = 1.0 @@ -53,7 +53,7 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = 1.0 - rates[1] = variables[0] + rates[1] = constants[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 1f99605fa..d25ae1df3 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -72,9 +72,9 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - variables[2] = u[0]; + algebraic[2] = u[0]; - f[0] = 1.0-(states[0]+states[1]+variables[2]); + f[0] = 1.0-(states[0]+states[1]+algebraic[2]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -82,19 +82,19 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = variables[2]; + u[0] = algebraic[2]; nlaSolve(objectiveFunction0, u, 1, &rfi); - variables[2] = u[0]; + algebraic[2] = u[0]; } void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 0.04; - variables[1] = 1.0e4; - variables[2] = 0.0; - variables[3] = 3.0e7; + constants[0] = 0.04; + constants[1] = 1.0e4; + algebraic[2] = 0.0; + constants[3] = 3.0e7; states[0] = 1.0; states[1] = 0.0; } @@ -106,12 +106,12 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, variables); - rates[0] = -variables[0]*states[0]+variables[1]*states[1]*variables[2]; - rates[1] = variables[0]*states[0]-variables[3]*pow(states[1], 2.0)-variables[1]*states[1]*variables[2]; + rates[0] = -constants[0]*states[0]+constants[1]*states[1]*algebraic[2]; + rates[1] = constants[0]*states[0]-constants[3]*pow(states[1], 2.0)-constants[1]*states[1]*algebraic[2]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, variables); - variables[4] = 10000.0*states[1]; + algebraic[4] = 10000.0*states[1]; } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 02d98e3c7..a01a61531 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -54,26 +54,26 @@ def objective_function_0(u, f, data): rates = data[2] variables = data[3] - variables[2] = u[0] + algebraic[2] = u[0] - f[0] = 1.0-(states[0]+states[1]+variables[2]) + f[0] = 1.0-(states[0]+states[1]+algebraic[2]) def find_root_0(voi, states, rates, variables): u = [nan]*1 - u[0] = variables[2] + u[0] = algebraic[2] u = nla_solve(objective_function_0, u, 1, [voi, states, rates, variables]) - variables[2] = u[0] + algebraic[2] = u[0] def initialise_variables(states, rates, constants): - variables[0] = 0.04 - variables[1] = 1.0e4 - variables[2] = 0.0 - variables[3] = 3.0e7 + constants[0] = 0.04 + constants[1] = 1.0e4 + algebraic[2] = 0.0 + constants[3] = 3.0e7 states[0] = 1.0 states[1] = 0.0 @@ -84,10 +84,10 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, variables) - rates[0] = -variables[0]*states[0]+variables[1]*states[1]*variables[2] - rates[1] = variables[0]*states[0]-variables[3]*pow(states[1], 2.0)-variables[1]*states[1]*variables[2] + rates[0] = -constants[0]*states[0]+constants[1]*states[1]*algebraic[2] + rates[1] = constants[0]*states[0]-constants[3]*pow(states[1], 2.0)-constants[1]*states[1]*algebraic[2] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, variables) - variables[4] = 10000.0*states[1] + algebraic[4] = 10000.0*states[1] diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 755412f68..c513ea1bd 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -57,9 +57,9 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 0.04; - variables[1] = 1.0e4; - variables[2] = 3.0e7; + constants[0] = 0.04; + constants[1] = 1.0e4; + constants[2] = 3.0e7; states[0] = 1.0; states[1] = 0.0; states[2] = 0.0; @@ -71,12 +71,12 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = -variables[0]*states[0]+variables[1]*states[2]*states[1]; - rates[2] = variables[0]*states[0]-variables[2]*pow(states[2], 2.0)-variables[1]*states[2]*states[1]; - rates[1] = variables[2]*pow(states[2], 2.0); + rates[0] = -constants[0]*states[0]+constants[1]*states[2]*states[1]; + rates[2] = constants[0]*states[0]-constants[2]*pow(states[2], 2.0)-constants[1]*states[2]*states[1]; + rates[1] = constants[2]*pow(states[2], 2.0); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[3] = 10000.0*states[2]; + algebraic[3] = 10000.0*states[2]; } diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 5fba7eba4..5724071fc 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -46,9 +46,9 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 0.04 - variables[1] = 1.0e4 - variables[2] = 3.0e7 + constants[0] = 0.04 + constants[1] = 1.0e4 + constants[2] = 3.0e7 states[0] = 1.0 states[1] = 0.0 states[2] = 0.0 @@ -59,10 +59,10 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = -variables[0]*states[0]+variables[1]*states[2]*states[1] - rates[2] = variables[0]*states[0]-variables[2]*pow(states[2], 2.0)-variables[1]*states[2]*states[1] - rates[1] = variables[2]*pow(states[2], 2.0) + rates[0] = -constants[0]*states[0]+constants[1]*states[2]*states[1] + rates[2] = constants[0]*states[0]-constants[2]*pow(states[2], 2.0)-constants[1]*states[2]*states[1] + rates[1] = constants[2]*pow(states[2], 2.0) def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[3] = 10000.0*states[2] + algebraic[3] = 10000.0*states[2] diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 29f467ca1..6dfb92f02 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -61,14 +61,14 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[1] = 0.0; - variables[3] = 0.75; - variables[4] = 2.0/3.14159265358979; - variables[5] = 2.0*3.14159265358979; - variables[6] = 3.14159265358979/2.0; - variables[7] = 3.14159265358979; - variables[8] = 3.0*3.14159265358979/2.0; - states[0] = variables[1]; + constants[1] = 0.0; + constants[3] = 0.75; + computedConstants[4] = 2.0/3.14159265358979; + computedConstants[5] = 2.0*3.14159265358979; + computedConstants[6] = 3.14159265358979/2.0; + computedConstants[7] = 3.14159265358979; + computedConstants[8] = 3.0*3.14159265358979/2.0; + states[0] = constants[1]; } void computeComputedConstants(double *constants, double *computedConstants) @@ -82,7 +82,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - variables[0] = sin(voi); - variables[9] = (voi < variables[6])?voi*variables[4]-0.5:(voi < variables[7])?(3.14159265358979-voi)*variables[4]-0.5:(voi < variables[8])?(voi-3.14159265358979)*variables[4]-0.5:(variables[5]-voi)*variables[4]-0.5; - variables[2] = (voi < variables[6])?-variables[9]*variables[9]+variables[3]+variables[9]:(voi < variables[7])?-variables[9]*variables[9]+variables[3]+variables[9]:(voi < variables[8])?variables[9]*variables[9]-variables[3]-variables[9]:variables[9]*variables[9]-variables[3]-variables[9]; + algebraic[0] = sin(voi); + algebraic[9] = (voi < computedConstants[6])?voi*computedConstants[4]-0.5:(voi < computedConstants[7])?(3.14159265358979-voi)*computedConstants[4]-0.5:(voi < computedConstants[8])?(voi-3.14159265358979)*computedConstants[4]-0.5:(computedConstants[5]-voi)*computedConstants[4]-0.5; + algebraic[2] = (voi < computedConstants[6])?-algebraic[9]*algebraic[9]+constants[3]+algebraic[9]:(voi < computedConstants[7])?-algebraic[9]*algebraic[9]+constants[3]+algebraic[9]:(voi < computedConstants[8])?algebraic[9]*algebraic[9]-constants[3]-algebraic[9]:algebraic[9]*algebraic[9]-constants[3]-algebraic[9]; } diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 3319297ff..2c2c46397 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -54,14 +54,14 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[1] = 0.0 - variables[3] = 0.75 - variables[4] = 2.0/3.14159265358979 - variables[5] = 2.0*3.14159265358979 - variables[6] = 3.14159265358979/2.0 - variables[7] = 3.14159265358979 - variables[8] = 3.0*3.14159265358979/2.0 - states[0] = variables[1] + constants[1] = 0.0 + constants[3] = 0.75 + computed_constants[4] = 2.0/3.14159265358979 + computed_constants[5] = 2.0*3.14159265358979 + computed_constants[6] = 3.14159265358979/2.0 + computed_constants[7] = 3.14159265358979 + computed_constants[8] = 3.0*3.14159265358979/2.0 + states[0] = constants[1] def compute_computed_constants(constants, computed_constants): @@ -73,6 +73,6 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - variables[0] = sin(voi) - variables[9] = voi*variables[4]-0.5 if lt_func(voi, variables[6]) else (3.14159265358979-voi)*variables[4]-0.5 if lt_func(voi, variables[7]) else (voi-3.14159265358979)*variables[4]-0.5 if lt_func(voi, variables[8]) else (variables[5]-voi)*variables[4]-0.5 - variables[2] = -variables[9]*variables[9]+variables[3]+variables[9] if lt_func(voi, variables[6]) else -variables[9]*variables[9]+variables[3]+variables[9] if lt_func(voi, variables[7]) else variables[9]*variables[9]-variables[3]-variables[9] if lt_func(voi, variables[8]) else variables[9]*variables[9]-variables[3]-variables[9] + algebraic[0] = sin(voi) + algebraic[9] = voi*computed_constants[4]-0.5 if lt_func(voi, computed_constants[6]) else (3.14159265358979-voi)*computed_constants[4]-0.5 if lt_func(voi, computed_constants[7]) else (voi-3.14159265358979)*computed_constants[4]-0.5 if lt_func(voi, computed_constants[8]) else (computed_constants[5]-voi)*computed_constants[4]-0.5 + algebraic[2] = -algebraic[9]*algebraic[9]+constants[3]+algebraic[9] if lt_func(voi, computed_constants[6]) else -algebraic[9]*algebraic[9]+constants[3]+algebraic[9] if lt_func(voi, computed_constants[7]) else algebraic[9]*algebraic[9]-constants[3]-algebraic[9] if lt_func(voi, computed_constants[8]) else algebraic[9]*algebraic[9]-constants[3]-algebraic[9] diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 1d5fac7e8..8167206cd 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -43,15 +43,15 @@ void deleteArray(double *array) void initialiseVariables(double *constants, ExternalVariable externalVariable) { - variables[1] = 1.1; - variables[2] = 21262500.0; - variables[3] = 150.0; - variables[4] = 3402000.0; - variables[5] = 2.0; - variables[6] = 2902500.0; - variables[7] = 810000.0; - variables[8] = 247140.0; - variables[9] = externalVariable(variables, 9); + constants[1] = 1.1; + constants[2] = 21262500.0; + constants[3] = 150.0; + constants[4] = 3402000.0; + constants[5] = 2.0; + constants[6] = 2902500.0; + constants[7] = 810000.0; + constants[8] = 247140.0; + algebraic[9] = externalVariable(variables, 9); } void computeComputedConstants(double *constants, double *computedConstants) @@ -60,6 +60,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - variables[9] = externalVariable(variables, 9); - variables[0] = variables[1]*(variables[2]*variables[3]-variables[4]*variables[5])/(variables[6]*variables[5]+variables[9]*variables[3]+variables[8]*variables[5]*variables[3]+variables[7]); + algebraic[9] = externalVariable(variables, 9); + algebraic[0] = constants[1]*(constants[2]*constants[3]-constants[4]*constants[5])/(constants[6]*constants[5]+algebraic[9]*constants[3]+constants[8]*constants[5]*constants[3]+constants[7]); } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 8f2c23fba..3c5f0470c 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -38,15 +38,15 @@ def create_variables_array(): def initialise_variables(constants, external_variable): - variables[1] = 1.1 - variables[2] = 21262500.0 - variables[3] = 150.0 - variables[4] = 3402000.0 - variables[5] = 2.0 - variables[6] = 2902500.0 - variables[7] = 810000.0 - variables[8] = 247140.0 - variables[9] = external_variable(variables, 9) + constants[1] = 1.1 + constants[2] = 21262500.0 + constants[3] = 150.0 + constants[4] = 3402000.0 + constants[5] = 2.0 + constants[6] = 2902500.0 + constants[7] = 810000.0 + constants[8] = 247140.0 + algebraic[9] = external_variable(variables, 9) def compute_computed_constants(constants, computed_constants): @@ -54,5 +54,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - variables[9] = external_variable(variables, 9) - variables[0] = variables[1]*(variables[2]*variables[3]-variables[4]*variables[5])/(variables[6]*variables[5]+variables[9]*variables[3]+variables[8]*variables[5]*variables[3]+variables[7]) + algebraic[9] = external_variable(variables, 9) + algebraic[0] = constants[1]*(constants[2]*constants[3]-constants[4]*constants[5])/(constants[6]*constants[5]+algebraic[9]*constants[3]+constants[8]*constants[5]*constants[3]+constants[7]) diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index bbd31e50c..79800b918 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -52,8 +52,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - variables[0] = 7.0; - states[0] = variables[0]; + constants[0] = 7.0; + states[0] = constants[0]; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index e6b607b12..54a115939 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -41,8 +41,8 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - variables[0] = 7.0 - states[0] = variables[0] + constants[0] = 7.0 + states[0] = constants[0] def compute_computed_constants(constants, computed_constants): From 01bfdec489adc37a2e40fd2ed7ccce0da45d0360 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 8 Aug 2024 11:34:04 +0200 Subject: [PATCH 11/74] Analyser: track the constant, computed constant, and algebraic indexes. --- src/analyser.cpp | 32 +- tests/bindings/python/test_analyser.py | 2 +- tests/resources/coverage/generator/model.c | 434 +++++------ .../generator/model.implementation.out | 434 +++++------ .../generator/model.modified.profile.c | 434 +++++------ .../generator/model.modified.profile.py | 434 +++++------ tests/resources/coverage/generator/model.out | 434 +++++------ tests/resources/coverage/generator/model.py | 434 +++++------ .../algebraic_eqn_const_var_on_rhs/model.c | 4 +- .../algebraic_eqn_const_var_on_rhs/model.py | 4 +- .../algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../model.c | 10 +- .../model.external.c | 4 +- .../model.external.py | 4 +- .../model.py | 10 +- .../model.not.ordered.c | 10 +- .../model.not.ordered.py | 10 +- .../model.ordered.c | 28 +- .../model.ordered.py | 28 +- .../generator/cell_geometry_model/model.c | 8 +- .../generator/cell_geometry_model/model.py | 8 +- .../generator/cellml_slc_example/model.py | 20 +- .../cellml_unit_scaling_constant/model.c | 4 +- .../cellml_unit_scaling_constant/model.py | 4 +- .../generator/dae_cellml_1_1_model/model.c | 34 +- .../generator/dae_cellml_1_1_model/model.py | 34 +- .../model.c | 684 +++++++++--------- .../model.py | 684 +++++++++--------- .../model.c | 504 ++++++------- .../model.py | 504 ++++++------- .../model.algebraic.c | 60 +- .../model.algebraic.py | 60 +- .../model.c | 60 +- .../model.computed.constant.c | 64 +- .../model.computed.constant.py | 64 +- .../model.constant.c | 56 +- .../model.constant.py | 56 +- .../model.dae.c | 114 +-- .../model.dae.py | 114 +-- .../model.dependent.algebraic.c | 62 +- .../model.dependent.algebraic.py | 62 +- .../model.dependent.computed.constant.c | 72 +- .../model.dependent.computed.constant.py | 72 +- .../model.dependent.constant.c | 60 +- .../model.dependent.constant.py | 60 +- .../model.dependent.state.c | 42 +- .../model.dependent.state.py | 42 +- .../model.external.c | 42 +- .../model.external.py | 42 +- .../model.py | 60 +- .../model.state.c | 60 +- .../model.state.py | 60 +- .../generator/noble_model_1962/model.c | 66 +- .../generator/noble_model_1962/model.py | 66 +- .../robertson_model_1966/model.dae.c | 18 +- .../robertson_model_1966/model.dae.py | 18 +- .../robertson_model_1966/model.ode.c | 2 +- .../robertson_model_1966/model.ode.py | 2 +- .../generator/sine_model_imports/model.c | 20 +- .../generator/sine_model_imports/model.py | 20 +- .../model.c | 22 +- .../model.py | 22 +- 69 files changed, 3455 insertions(+), 3439 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index 23a693861..d9a48da5d 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -208,7 +208,8 @@ struct AnalyserInternalEquation bool variableOnRhs(const AnalyserInternalVariablePtr &variable); bool variableOnLhsOrRhs(const AnalyserInternalVariablePtr &variable); - bool check(const AnalyserModelPtr &model, size_t &stateIndex, size_t &variableIndex, bool checkNlaSystems); + bool check(const AnalyserModelPtr &model, size_t &stateIndex, size_t &constantIndex, + size_t &computedConstantIndex, size_t &algebraicIndex, bool checkNlaSystems); }; AnalyserInternalEquationPtr AnalyserInternalEquation::create(const ComponentPtr &component) @@ -321,7 +322,8 @@ bool AnalyserInternalEquation::variableOnLhsOrRhs(const AnalyserInternalVariable } bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, - size_t &stateIndex, size_t &variableIndex, + size_t &stateIndex, size_t &constantIndex, + size_t &computedConstantIndex, size_t &algebraicIndex, bool checkNlaSystems) { // Nothing to check if the equation has a known type. @@ -437,7 +439,12 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, case AnalyserInternalVariable::Type::ALGEBRAIC: variable->mIndex = (variable->mType == AnalyserInternalVariable::Type::STATE) ? ++stateIndex : - ++variableIndex; + (variable->mType == AnalyserInternalVariable::Type::CONSTANT) ? + ++constantIndex : + ((variable->mType == AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT) + || (variable->mType == AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT)) ? + ++computedConstantIndex : + ++algebraicIndex; mUnknownVariables.push_back(variable); @@ -2748,7 +2755,9 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // model valid). auto stateIndex = MAX_SIZE_T; - auto variableIndex = MAX_SIZE_T; + auto constantIndex = MAX_SIZE_T; + auto computedConstantIndex = MAX_SIZE_T; + auto algebraicIndex = MAX_SIZE_T; auto loopNumber = 1; bool relevantCheck; auto checkNlaSystems = false; @@ -2757,7 +2766,8 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) relevantCheck = false; for (const auto &internalEquation : mInternalEquations) { - relevantCheck = internalEquation->check(mModel, stateIndex, variableIndex, checkNlaSystems) + relevantCheck = internalEquation->check(mModel, stateIndex, constantIndex, computedConstantIndex, + algebraicIndex, checkNlaSystems) || relevantCheck; } @@ -2802,7 +2812,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) case AnalyserInternalVariable::Type::INITIALISED: // The variable is (still) initialised so it has to be a constant. - internalVariable->makeConstant(variableIndex); + internalVariable->makeConstant(constantIndex); break; case AnalyserInternalVariable::Type::OVERCONSTRAINED: @@ -3058,7 +3068,9 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) std::map v2avMappings; stateIndex = MAX_SIZE_T; - variableIndex = MAX_SIZE_T; + constantIndex = MAX_SIZE_T; + computedConstantIndex = MAX_SIZE_T; + algebraicIndex = MAX_SIZE_T; for (const auto &internalVariable : mInternalVariables) { // Determine the type of the variable. @@ -3108,7 +3120,11 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) variable->mPimpl->populate(type, (type == AnalyserVariable::Type::STATE) ? ++stateIndex : - ++variableIndex, + (type == AnalyserVariable::Type::CONSTANT) ? + ++constantIndex : + (type == AnalyserVariable::Type::COMPUTED_CONSTANT) ? + ++computedConstantIndex : + ++algebraicIndex, (type == AnalyserVariable::Type::EXTERNAL) ? nullptr : internalVariable->mInitialisingVariable, diff --git a/tests/bindings/python/test_analyser.py b/tests/bindings/python/test_analyser.py index 3895e4b40..ca3d36b0e 100644 --- a/tests/bindings/python/test_analyser.py +++ b/tests/bindings/python/test_analyser.py @@ -163,7 +163,7 @@ def test_coverage(self): self.assertEqual(AnalyserVariable.Type.CONSTANT, av.type()) self.assertEqual("constant", AnalyserVariable.typeAsString(av.type())) self.assertEqual("constant", AnalyserVariable_typeAsString(av.type())) - self.assertEqual(3, av.index()) + self.assertEqual(0, av.index()) self.assertIsNotNone(av.initialisingVariable()) self.assertIsNotNone(av.variable()) self.assertEqual(1, av.equationCount()) diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 872419de4..0918ab6d4 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -356,11 +356,11 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[205] = u[0]; - algebraic[206] = u[1]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; - f[0] = algebraic[205]+algebraic[206]+states[0]-0.0; - f[1] = algebraic[205]-algebraic[206]-(computedConstants[207]+computedConstants[208]); + f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; + f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -368,231 +368,231 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[2]; - u[0] = algebraic[205]; - u[1] = algebraic[206]; + u[0] = algebraic[0]; + u[1] = algebraic[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[205] = u[0]; - algebraic[206] = u[1]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; } void initialiseVariables(double *states, double *rates, double *constants) { - constants[1] = 1.0; - constants[2] = 2.0; - constants[6] = 3.0; - constants[18] = 4.0; - constants[179] = 5.0; - constants[180] = 6.0; - constants[182] = 7.0; - algebraic[205] = 1.0; - algebraic[206] = 2.0; - computedConstants[184] = 123.0; - computedConstants[185] = 123.456789; - computedConstants[186] = 123.0e99; - computedConstants[187] = 123.456789e99; - computedConstants[189] = 1.0; - computedConstants[190] = 0.0; - computedConstants[191] = 2.71828182845905; - computedConstants[192] = 3.14159265358979; - computedConstants[193] = INFINITY; - computedConstants[194] = NAN; - computedConstants[207] = 1.0; - computedConstants[208] = 3.0; + constants[0] = 1.0; + constants[1] = 2.0; + constants[2] = 3.0; + constants[3] = 4.0; + constants[4] = 5.0; + constants[5] = 6.0; + constants[6] = 7.0; + algebraic[0] = 1.0; + algebraic[1] = 2.0; + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = constants[1] == constants[2]; - computedConstants[3] = constants[1]/(constants[2] == constants[2]); - computedConstants[4] = constants[1] != constants[2]; - computedConstants[5] = constants[1]/(constants[2] != constants[6]); - computedConstants[7] = constants[1] < constants[2]; - computedConstants[8] = constants[1]/(constants[2] < constants[6]); - computedConstants[9] = constants[1] <= constants[2]; - computedConstants[10] = constants[1]/(constants[2] <= constants[6]); - computedConstants[11] = constants[1] > constants[2]; - computedConstants[12] = constants[1]/(constants[2] > constants[6]); - computedConstants[13] = constants[1] >= constants[2]; - computedConstants[14] = constants[1]/(constants[2] >= constants[6]); - computedConstants[15] = constants[1] && constants[2]; - computedConstants[16] = constants[1] && constants[2] && constants[6]; - computedConstants[17] = (constants[1] < constants[2]) && (constants[6] > constants[18]); - computedConstants[19] = (constants[1]+constants[2]) && (constants[6] > constants[18]); - computedConstants[20] = constants[1] && (constants[2] > constants[6]); - computedConstants[21] = (constants[1]-constants[2]) && (constants[6] > constants[18]); - computedConstants[22] = -constants[1] && (constants[2] > constants[6]); - computedConstants[23] = pow(constants[1], constants[2]) && (constants[6] > constants[18]); - computedConstants[24] = pow(constants[1], 1.0/constants[2]) && (constants[6] > constants[18]); - computedConstants[25] = (constants[1] < constants[2]) && (constants[6]+constants[18]); - computedConstants[26] = (constants[1] < constants[2]) && constants[6]; - computedConstants[27] = (constants[1] < constants[2]) && (constants[6]-constants[18]); - computedConstants[28] = (constants[1] < constants[2]) && -constants[6]; - computedConstants[29] = (constants[1] < constants[2]) && pow(constants[6], constants[18]); - computedConstants[30] = (constants[1] < constants[2]) && pow(constants[6], 1.0/constants[18]); - computedConstants[31] = constants[1]/(constants[2] && constants[6]); - computedConstants[32] = constants[1] || constants[2]; - computedConstants[33] = constants[1] || constants[2] || constants[6]; - computedConstants[34] = (constants[1] < constants[2]) || (constants[6] > constants[18]); - computedConstants[35] = (constants[1]+constants[2]) || (constants[6] > constants[18]); - computedConstants[36] = constants[1] || (constants[2] > constants[6]); - computedConstants[37] = (constants[1]-constants[2]) || (constants[6] > constants[18]); - computedConstants[38] = -constants[1] || (constants[2] > constants[6]); - computedConstants[39] = pow(constants[1], constants[2]) || (constants[6] > constants[18]); - computedConstants[40] = pow(constants[1], 1.0/constants[2]) || (constants[6] > constants[18]); - computedConstants[41] = (constants[1] < constants[2]) || (constants[6]+constants[18]); - computedConstants[42] = (constants[1] < constants[2]) || constants[6]; - computedConstants[43] = (constants[1] < constants[2]) || (constants[6]-constants[18]); - computedConstants[44] = (constants[1] < constants[2]) || -constants[6]; - computedConstants[45] = (constants[1] < constants[2]) || pow(constants[6], constants[18]); - computedConstants[46] = (constants[1] < constants[2]) || pow(constants[6], 1.0/constants[18]); - computedConstants[47] = constants[1]/(constants[2] || constants[6]); - computedConstants[48] = xor(constants[1], constants[2]); - computedConstants[49] = xor(constants[1], xor(constants[2], constants[6])); - computedConstants[50] = xor(constants[1] < constants[2], constants[6] > constants[18]); - computedConstants[51] = xor(constants[1]+constants[2], constants[6] > constants[18]); - computedConstants[52] = xor(constants[1], constants[2] > constants[6]); - computedConstants[53] = xor(constants[1]-constants[2], constants[6] > constants[18]); - computedConstants[54] = xor(-constants[1], constants[2] > constants[6]); - computedConstants[55] = xor(pow(constants[1], constants[2]), constants[6] > constants[18]); - computedConstants[56] = xor(pow(constants[1], 1.0/constants[2]), constants[6] > constants[18]); - computedConstants[57] = xor(constants[1] < constants[2], constants[6]+constants[18]); - computedConstants[58] = xor(constants[1] < constants[2], constants[6]); - computedConstants[59] = xor(constants[1] < constants[2], constants[6]-constants[18]); - computedConstants[60] = xor(constants[1] < constants[2], -constants[6]); - computedConstants[61] = xor(constants[1] < constants[2], pow(constants[6], constants[18])); - computedConstants[62] = xor(constants[1] < constants[2], pow(constants[6], 1.0/constants[18])); - computedConstants[63] = constants[1]/xor(constants[2], constants[6]); - computedConstants[64] = !constants[1]; - computedConstants[65] = constants[1]+constants[2]; - computedConstants[66] = constants[1]+constants[2]+constants[6]; - computedConstants[67] = (constants[1] < constants[2])+(constants[6] > constants[18]); - computedConstants[68] = constants[1]; - computedConstants[69] = constants[1]-constants[2]; - computedConstants[70] = (constants[1] < constants[2])-(constants[6] > constants[18]); - computedConstants[71] = (constants[1] < constants[2])-(constants[6]+constants[18]); - computedConstants[72] = (constants[1] < constants[2])-constants[6]; - computedConstants[73] = constants[1]-(-constants[2]); - computedConstants[74] = constants[1]-(-constants[2]*constants[6]); - computedConstants[75] = -constants[1]; - computedConstants[76] = -(constants[1] < constants[2]); - computedConstants[77] = constants[1]*constants[2]; - computedConstants[78] = constants[1]*constants[2]*constants[6]; - computedConstants[79] = (constants[1] < constants[2])*(constants[6] > constants[18]); - computedConstants[80] = (constants[1]+constants[2])*(constants[6] > constants[18]); - computedConstants[81] = constants[1]*(constants[2] > constants[6]); - computedConstants[82] = (constants[1]-constants[2])*(constants[6] > constants[18]); - computedConstants[83] = -constants[1]*(constants[2] > constants[6]); - computedConstants[84] = (constants[1] < constants[2])*(constants[6]+constants[18]); - computedConstants[85] = (constants[1] < constants[2])*constants[6]; - computedConstants[86] = (constants[1] < constants[2])*(constants[6]-constants[18]); - computedConstants[87] = (constants[1] < constants[2])*-constants[6]; - computedConstants[88] = constants[1]/constants[2]; - computedConstants[89] = (constants[1] < constants[2])/(constants[18] > constants[6]); - computedConstants[90] = (constants[1]+constants[2])/(constants[18] > constants[6]); - computedConstants[91] = constants[1]/(constants[6] > constants[2]); - computedConstants[92] = (constants[1]-constants[2])/(constants[18] > constants[6]); - computedConstants[93] = -constants[1]/(constants[6] > constants[2]); - computedConstants[94] = (constants[1] < constants[2])/(constants[6]+constants[18]); - computedConstants[95] = (constants[1] < constants[2])/constants[6]; - computedConstants[96] = (constants[1] < constants[2])/(constants[6]-constants[18]); - computedConstants[97] = (constants[1] < constants[2])/-constants[6]; - computedConstants[98] = (constants[1] < constants[2])/(constants[6]*constants[18]); - computedConstants[99] = (constants[1] < constants[2])/(constants[6]/constants[18]); - computedConstants[100] = sqrt(constants[1]); - computedConstants[101] = pow(constants[1], 2.0); - computedConstants[102] = pow(constants[1], 3.0); - computedConstants[103] = pow(constants[1], constants[2]); - computedConstants[104] = pow(constants[1] <= constants[2], constants[6] >= constants[18]); - computedConstants[105] = pow(constants[1]+constants[2], constants[6] >= constants[18]); - computedConstants[106] = pow(constants[1], constants[2] >= constants[6]); - computedConstants[107] = pow(constants[1]-constants[2], constants[6] >= constants[18]); - computedConstants[108] = pow(-constants[1], constants[2] >= constants[6]); - computedConstants[109] = pow(constants[1]*constants[2], constants[6] >= constants[18]); - computedConstants[110] = pow(constants[1]/constants[2], constants[6] >= constants[18]); - computedConstants[111] = pow(constants[1] <= constants[2], constants[6]+constants[18]); - computedConstants[112] = pow(constants[1] <= constants[2], constants[6]); - computedConstants[113] = pow(constants[1] <= constants[2], constants[6]-constants[18]); - computedConstants[114] = pow(constants[1] <= constants[2], -constants[6]); - computedConstants[115] = pow(constants[1] <= constants[2], constants[6]*constants[18]); - computedConstants[116] = pow(constants[1] <= constants[2], constants[6]/constants[18]); - computedConstants[117] = pow(constants[1] <= constants[2], pow(constants[6], constants[18])); - computedConstants[118] = pow(constants[1] <= constants[2], pow(constants[6], 1.0/constants[18])); - computedConstants[119] = sqrt(constants[1]); - computedConstants[120] = sqrt(constants[1]); - computedConstants[121] = pow(constants[1], 1.0/3.0); - computedConstants[122] = pow(constants[1], 1.0/constants[2]); - computedConstants[123] = pow(constants[1] < constants[2], 1.0/(constants[18] > constants[6])); - computedConstants[124] = pow(constants[1]+constants[2], 1.0/(constants[18] > constants[6])); - computedConstants[125] = pow(constants[1], 1.0/(constants[6] > constants[2])); - computedConstants[126] = pow(constants[1]-constants[2], 1.0/(constants[18] > constants[6])); - computedConstants[127] = pow(-constants[1], 1.0/(constants[6] > constants[2])); - computedConstants[128] = pow(constants[1]*constants[2], 1.0/(constants[18] > constants[6])); - computedConstants[129] = pow(constants[1]/constants[2], 1.0/(constants[18] > constants[6])); - computedConstants[130] = pow(constants[1] < constants[2], 1.0/(constants[6]+constants[18])); - computedConstants[131] = pow(constants[1] < constants[2], 1.0/constants[6]); - computedConstants[132] = pow(constants[1] < constants[2], 1.0/(constants[6]-constants[18])); - computedConstants[133] = pow(constants[1] < constants[2], 1.0/-constants[6]); - computedConstants[134] = pow(constants[1] < constants[2], 1.0/(constants[6]*constants[18])); - computedConstants[135] = pow(constants[1] < constants[2], 1.0/(constants[6]/constants[18])); - computedConstants[136] = pow(constants[1] < constants[2], 1.0/pow(constants[6], constants[18])); - computedConstants[137] = pow(constants[1] < constants[2], 1.0/pow(constants[6], 1.0/constants[18])); - computedConstants[138] = fabs(constants[1]); - computedConstants[139] = exp(constants[1]); - computedConstants[140] = log(constants[1]); - computedConstants[141] = log10(constants[1]); - computedConstants[142] = log(constants[1])/log(2.0); - computedConstants[143] = log10(constants[1]); - computedConstants[144] = log(constants[1])/log(constants[2]); - computedConstants[145] = ceil(constants[1]); - computedConstants[146] = floor(constants[1]); - computedConstants[147] = min(constants[1], constants[2]); - computedConstants[148] = min(constants[1], min(constants[2], constants[6])); - computedConstants[149] = max(constants[1], constants[2]); - computedConstants[150] = max(constants[1], max(constants[2], constants[6])); - computedConstants[151] = fmod(constants[1], constants[2]); - computedConstants[152] = sin(constants[1]); - computedConstants[153] = cos(constants[1]); - computedConstants[154] = tan(constants[1]); - computedConstants[155] = sec(constants[1]); - computedConstants[156] = csc(constants[1]); - computedConstants[157] = cot(constants[1]); - computedConstants[158] = sinh(constants[1]); - computedConstants[159] = cosh(constants[1]); - computedConstants[160] = tanh(constants[1]); - computedConstants[161] = sech(constants[1]); - computedConstants[162] = csch(constants[1]); - computedConstants[163] = coth(constants[1]); - computedConstants[164] = asin(constants[1]); - computedConstants[165] = acos(constants[1]); - computedConstants[166] = atan(constants[1]); - computedConstants[167] = asec(constants[1]); - computedConstants[168] = acsc(constants[1]); - computedConstants[169] = acot(constants[1]); - computedConstants[170] = asinh(constants[1]); - computedConstants[171] = acosh(constants[1]); - computedConstants[172] = atanh(constants[1]/2.0); - computedConstants[173] = asech(constants[1]); - computedConstants[174] = acsch(constants[1]); - computedConstants[175] = acoth(2.0*constants[1]); - computedConstants[176] = (constants[1] > constants[2])?constants[1]:NAN; - computedConstants[177] = (constants[1] > constants[2])?constants[1]:constants[6]; - computedConstants[178] = (constants[1] > constants[2])?constants[1]:(constants[6] > constants[18])?constants[6]:(constants[179] > constants[180])?constants[179]:NAN; - computedConstants[181] = (constants[1] > constants[2])?constants[1]:(constants[6] > constants[18])?constants[6]:(constants[179] > constants[180])?constants[179]:constants[182]; - computedConstants[183] = 123.0+((constants[1] > constants[2])?constants[1]:NAN); - computedConstants[188] = constants[1]; - computedConstants[195] = (constants[1] && constants[2])+((constants[6] > constants[18])?constants[2]:NAN)+constants[179]+(constants[180] && constants[182]); - computedConstants[196] = (constants[1] && constants[2])-(((constants[6] > constants[18])?constants[2]:NAN)-(constants[179]-((constants[6] > constants[18])?constants[2]:NAN)))-(constants[180] && constants[182]); - computedConstants[197] = (constants[1] && constants[2])*((constants[6] > constants[18])?constants[2]:NAN)*constants[179]*((constants[6] > constants[18])?constants[2]:NAN)*(constants[180] && constants[182]); - computedConstants[198] = (constants[1] && constants[2])/(((constants[6] > constants[18])?constants[2]:NAN)/(constants[179]/((constants[6] > constants[18])?constants[2]:NAN))); - computedConstants[199] = (constants[1] || constants[2]) && xor(constants[1], constants[2]) && ((constants[6] > constants[18])?constants[2]:NAN) && constants[179] && ((constants[6] > constants[18])?constants[2]:NAN) && xor(constants[1], constants[2]) && (constants[1] || constants[2]); - computedConstants[200] = (constants[1] && constants[2]) || xor(constants[1], constants[2]) || ((constants[6] > constants[18])?constants[2]:NAN) || constants[179] || ((constants[6] > constants[18])?constants[2]:NAN) || xor(constants[1], constants[2]) || (constants[1] && constants[2]); - computedConstants[201] = xor(constants[1] && constants[2], xor(constants[1] || constants[2], xor((constants[6] > constants[18])?constants[2]:NAN, xor(xor(xor(constants[179], (constants[6] > constants[18])?constants[2]:NAN), constants[1] || constants[2]), constants[1] && constants[2])))); - computedConstants[202] = pow(constants[1] && constants[2], pow((constants[6] > constants[18])?constants[2]:NAN, pow(pow(constants[179], (constants[6] > constants[18])?constants[2]:NAN), constants[1] && constants[2]))); - computedConstants[203] = pow(pow(pow(constants[1] && constants[2], 1.0/pow((constants[6] > constants[18])?constants[2]:NAN, 1.0/constants[179])), 1.0/((constants[6] > constants[18])?constants[2]:NAN)), 1.0/(constants[1] && constants[2])); - computedConstants[204] = -(constants[1] && constants[2])+-((constants[6] > constants[18])?constants[2]:NAN); + computedConstants[0] = constants[0] == constants[1]; + computedConstants[1] = constants[0]/(constants[1] == constants[1]); + computedConstants[2] = constants[0] != constants[1]; + computedConstants[3] = constants[0]/(constants[1] != constants[2]); + computedConstants[4] = constants[0] < constants[1]; + computedConstants[5] = constants[0]/(constants[1] < constants[2]); + computedConstants[6] = constants[0] <= constants[1]; + computedConstants[7] = constants[0]/(constants[1] <= constants[2]); + computedConstants[8] = constants[0] > constants[1]; + computedConstants[9] = constants[0]/(constants[1] > constants[2]); + computedConstants[10] = constants[0] >= constants[1]; + computedConstants[11] = constants[0]/(constants[1] >= constants[2]); + computedConstants[12] = constants[0] && constants[1]; + computedConstants[13] = constants[0] && constants[1] && constants[2]; + computedConstants[14] = (constants[0] < constants[1]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[0]+constants[1]) && (constants[2] > constants[3]); + computedConstants[16] = constants[0] && (constants[1] > constants[2]); + computedConstants[17] = (constants[0]-constants[1]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[0] && (constants[1] > constants[2]); + computedConstants[19] = pow(constants[0], constants[1]) && (constants[2] > constants[3]); + computedConstants[20] = pow(constants[0], 1.0/constants[1]) && (constants[2] > constants[3]); + computedConstants[21] = (constants[0] < constants[1]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[0] < constants[1]) && constants[2]; + computedConstants[23] = (constants[0] < constants[1]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[0] < constants[1]) && -constants[2]; + computedConstants[25] = (constants[0] < constants[1]) && pow(constants[2], constants[3]); + computedConstants[26] = (constants[0] < constants[1]) && pow(constants[2], 1.0/constants[3]); + computedConstants[27] = constants[0]/(constants[1] && constants[2]); + computedConstants[28] = constants[0] || constants[1]; + computedConstants[29] = constants[0] || constants[1] || constants[2]; + computedConstants[30] = (constants[0] < constants[1]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[0]+constants[1]) || (constants[2] > constants[3]); + computedConstants[32] = constants[0] || (constants[1] > constants[2]); + computedConstants[33] = (constants[0]-constants[1]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[0] || (constants[1] > constants[2]); + computedConstants[35] = pow(constants[0], constants[1]) || (constants[2] > constants[3]); + computedConstants[36] = pow(constants[0], 1.0/constants[1]) || (constants[2] > constants[3]); + computedConstants[37] = (constants[0] < constants[1]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[0] < constants[1]) || constants[2]; + computedConstants[39] = (constants[0] < constants[1]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[0] < constants[1]) || -constants[2]; + computedConstants[41] = (constants[0] < constants[1]) || pow(constants[2], constants[3]); + computedConstants[42] = (constants[0] < constants[1]) || pow(constants[2], 1.0/constants[3]); + computedConstants[43] = constants[0]/(constants[1] || constants[2]); + computedConstants[44] = xor(constants[0], constants[1]); + computedConstants[45] = xor(constants[0], xor(constants[1], constants[2])); + computedConstants[46] = xor(constants[0] < constants[1], constants[2] > constants[3]); + computedConstants[47] = xor(constants[0]+constants[1], constants[2] > constants[3]); + computedConstants[48] = xor(constants[0], constants[1] > constants[2]); + computedConstants[49] = xor(constants[0]-constants[1], constants[2] > constants[3]); + computedConstants[50] = xor(-constants[0], constants[1] > constants[2]); + computedConstants[51] = xor(pow(constants[0], constants[1]), constants[2] > constants[3]); + computedConstants[52] = xor(pow(constants[0], 1.0/constants[1]), constants[2] > constants[3]); + computedConstants[53] = xor(constants[0] < constants[1], constants[2]+constants[3]); + computedConstants[54] = xor(constants[0] < constants[1], constants[2]); + computedConstants[55] = xor(constants[0] < constants[1], constants[2]-constants[3]); + computedConstants[56] = xor(constants[0] < constants[1], -constants[2]); + computedConstants[57] = xor(constants[0] < constants[1], pow(constants[2], constants[3])); + computedConstants[58] = xor(constants[0] < constants[1], pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[0]/xor(constants[1], constants[2]); + computedConstants[60] = !constants[0]; + computedConstants[61] = constants[0]+constants[1]; + computedConstants[62] = constants[0]+constants[1]+constants[2]; + computedConstants[63] = (constants[0] < constants[1])+(constants[2] > constants[3]); + computedConstants[64] = constants[0]; + computedConstants[65] = constants[0]-constants[1]; + computedConstants[66] = (constants[0] < constants[1])-(constants[2] > constants[3]); + computedConstants[67] = (constants[0] < constants[1])-(constants[2]+constants[3]); + computedConstants[68] = (constants[0] < constants[1])-constants[2]; + computedConstants[69] = constants[0]-(-constants[1]); + computedConstants[70] = constants[0]-(-constants[1]*constants[2]); + computedConstants[71] = -constants[0]; + computedConstants[72] = -(constants[0] < constants[1]); + computedConstants[73] = constants[0]*constants[1]; + computedConstants[74] = constants[0]*constants[1]*constants[2]; + computedConstants[75] = (constants[0] < constants[1])*(constants[2] > constants[3]); + computedConstants[76] = (constants[0]+constants[1])*(constants[2] > constants[3]); + computedConstants[77] = constants[0]*(constants[1] > constants[2]); + computedConstants[78] = (constants[0]-constants[1])*(constants[2] > constants[3]); + computedConstants[79] = -constants[0]*(constants[1] > constants[2]); + computedConstants[80] = (constants[0] < constants[1])*(constants[2]+constants[3]); + computedConstants[81] = (constants[0] < constants[1])*constants[2]; + computedConstants[82] = (constants[0] < constants[1])*(constants[2]-constants[3]); + computedConstants[83] = (constants[0] < constants[1])*-constants[2]; + computedConstants[84] = constants[0]/constants[1]; + computedConstants[85] = (constants[0] < constants[1])/(constants[3] > constants[2]); + computedConstants[86] = (constants[0]+constants[1])/(constants[3] > constants[2]); + computedConstants[87] = constants[0]/(constants[2] > constants[1]); + computedConstants[88] = (constants[0]-constants[1])/(constants[3] > constants[2]); + computedConstants[89] = -constants[0]/(constants[2] > constants[1]); + computedConstants[90] = (constants[0] < constants[1])/(constants[2]+constants[3]); + computedConstants[91] = (constants[0] < constants[1])/constants[2]; + computedConstants[92] = (constants[0] < constants[1])/(constants[2]-constants[3]); + computedConstants[93] = (constants[0] < constants[1])/-constants[2]; + computedConstants[94] = (constants[0] < constants[1])/(constants[2]*constants[3]); + computedConstants[95] = (constants[0] < constants[1])/(constants[2]/constants[3]); + computedConstants[96] = sqrt(constants[0]); + computedConstants[97] = pow(constants[0], 2.0); + computedConstants[98] = pow(constants[0], 3.0); + computedConstants[99] = pow(constants[0], constants[1]); + computedConstants[100] = pow(constants[0] <= constants[1], constants[2] >= constants[3]); + computedConstants[101] = pow(constants[0]+constants[1], constants[2] >= constants[3]); + computedConstants[102] = pow(constants[0], constants[1] >= constants[2]); + computedConstants[103] = pow(constants[0]-constants[1], constants[2] >= constants[3]); + computedConstants[104] = pow(-constants[0], constants[1] >= constants[2]); + computedConstants[105] = pow(constants[0]*constants[1], constants[2] >= constants[3]); + computedConstants[106] = pow(constants[0]/constants[1], constants[2] >= constants[3]); + computedConstants[107] = pow(constants[0] <= constants[1], constants[2]+constants[3]); + computedConstants[108] = pow(constants[0] <= constants[1], constants[2]); + computedConstants[109] = pow(constants[0] <= constants[1], constants[2]-constants[3]); + computedConstants[110] = pow(constants[0] <= constants[1], -constants[2]); + computedConstants[111] = pow(constants[0] <= constants[1], constants[2]*constants[3]); + computedConstants[112] = pow(constants[0] <= constants[1], constants[2]/constants[3]); + computedConstants[113] = pow(constants[0] <= constants[1], pow(constants[2], constants[3])); + computedConstants[114] = pow(constants[0] <= constants[1], pow(constants[2], 1.0/constants[3])); + computedConstants[115] = sqrt(constants[0]); + computedConstants[116] = sqrt(constants[0]); + computedConstants[117] = pow(constants[0], 1.0/3.0); + computedConstants[118] = pow(constants[0], 1.0/constants[1]); + computedConstants[119] = pow(constants[0] < constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[120] = pow(constants[0]+constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[121] = pow(constants[0], 1.0/(constants[2] > constants[1])); + computedConstants[122] = pow(constants[0]-constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[123] = pow(-constants[0], 1.0/(constants[2] > constants[1])); + computedConstants[124] = pow(constants[0]*constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[125] = pow(constants[0]/constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[126] = pow(constants[0] < constants[1], 1.0/(constants[2]+constants[3])); + computedConstants[127] = pow(constants[0] < constants[1], 1.0/constants[2]); + computedConstants[128] = pow(constants[0] < constants[1], 1.0/(constants[2]-constants[3])); + computedConstants[129] = pow(constants[0] < constants[1], 1.0/-constants[2]); + computedConstants[130] = pow(constants[0] < constants[1], 1.0/(constants[2]*constants[3])); + computedConstants[131] = pow(constants[0] < constants[1], 1.0/(constants[2]/constants[3])); + computedConstants[132] = pow(constants[0] < constants[1], 1.0/pow(constants[2], constants[3])); + computedConstants[133] = pow(constants[0] < constants[1], 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[134] = fabs(constants[0]); + computedConstants[135] = exp(constants[0]); + computedConstants[136] = log(constants[0]); + computedConstants[137] = log10(constants[0]); + computedConstants[138] = log(constants[0])/log(2.0); + computedConstants[139] = log10(constants[0]); + computedConstants[140] = log(constants[0])/log(constants[1]); + computedConstants[141] = ceil(constants[0]); + computedConstants[142] = floor(constants[0]); + computedConstants[143] = min(constants[0], constants[1]); + computedConstants[144] = min(constants[0], min(constants[1], constants[2])); + computedConstants[145] = max(constants[0], constants[1]); + computedConstants[146] = max(constants[0], max(constants[1], constants[2])); + computedConstants[147] = fmod(constants[0], constants[1]); + computedConstants[148] = sin(constants[0]); + computedConstants[149] = cos(constants[0]); + computedConstants[150] = tan(constants[0]); + computedConstants[151] = sec(constants[0]); + computedConstants[152] = csc(constants[0]); + computedConstants[153] = cot(constants[0]); + computedConstants[154] = sinh(constants[0]); + computedConstants[155] = cosh(constants[0]); + computedConstants[156] = tanh(constants[0]); + computedConstants[157] = sech(constants[0]); + computedConstants[158] = csch(constants[0]); + computedConstants[159] = coth(constants[0]); + computedConstants[160] = asin(constants[0]); + computedConstants[161] = acos(constants[0]); + computedConstants[162] = atan(constants[0]); + computedConstants[163] = asec(constants[0]); + computedConstants[164] = acsc(constants[0]); + computedConstants[165] = acot(constants[0]); + computedConstants[166] = asinh(constants[0]); + computedConstants[167] = acosh(constants[0]); + computedConstants[168] = atanh(constants[0]/2.0); + computedConstants[169] = asech(constants[0]); + computedConstants[170] = acsch(constants[0]); + computedConstants[171] = acoth(2.0*constants[0]); + computedConstants[172] = (constants[0] > constants[1])?constants[0]:NAN; + computedConstants[173] = (constants[0] > constants[1])?constants[0]:constants[2]; + computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; + computedConstants[175] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; + computedConstants[176] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); + computedConstants[181] = constants[0]; + computedConstants[188] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[189] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); + computedConstants[190] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); + computedConstants[191] = (constants[0] && constants[1])/(((constants[2] > constants[3])?constants[1]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[1]:NAN))); + computedConstants[192] = (constants[0] || constants[1]) && xor(constants[0], constants[1]) && ((constants[2] > constants[3])?constants[1]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[1]:NAN) && xor(constants[0], constants[1]) && (constants[0] || constants[1]); + computedConstants[193] = (constants[0] && constants[1]) || xor(constants[0], constants[1]) || ((constants[2] > constants[3])?constants[1]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[1]:NAN) || xor(constants[0], constants[1]) || (constants[0] && constants[1]); + computedConstants[194] = xor(constants[0] && constants[1], xor(constants[0] || constants[1], xor((constants[2] > constants[3])?constants[1]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] || constants[1]), constants[0] && constants[1])))); + computedConstants[195] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); + computedConstants[196] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); + computedConstants[197] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 9656a1796..03233d917 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -125,11 +125,11 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[205] = u[0]; - algebraic[206] = u[1]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; - f[0] = algebraic[205]+algebraic[206]+states[0]-0.0; - f[1] = algebraic[205]-algebraic[206]-(computedConstants[207]+computedConstants[208]); + f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; + f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -137,231 +137,231 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[2]; - u[0] = algebraic[205]; - u[1] = algebraic[206]; + u[0] = algebraic[0]; + u[1] = algebraic[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[205] = u[0]; - algebraic[206] = u[1]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; } void initialiseVariables(double *states, double *rates, double *constants) { - constants[1] = 1.0; - constants[2] = 2.0; - constants[6] = 3.0; - constants[18] = 4.0; - constants[179] = 5.0; - constants[180] = 6.0; - constants[182] = 7.0; - algebraic[205] = 1.0; - algebraic[206] = 2.0; - computedConstants[184] = 123.0; - computedConstants[185] = 123.456789; - computedConstants[186] = 123.0e99; - computedConstants[187] = 123.456789e99; - computedConstants[189] = 1.0; - computedConstants[190] = 0.0; - computedConstants[191] = 2.71828182845905; - computedConstants[192] = 3.14159265358979; - computedConstants[193] = INFINITY; - computedConstants[194] = NAN; - computedConstants[207] = 1.0; - computedConstants[208] = 3.0; + constants[0] = 1.0; + constants[1] = 2.0; + constants[2] = 3.0; + constants[3] = 4.0; + constants[4] = 5.0; + constants[5] = 6.0; + constants[6] = 7.0; + algebraic[0] = 1.0; + algebraic[1] = 2.0; + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = eq(constants[1], constants[2]); - computedConstants[3] = constants[1]/eq(constants[2], constants[2]); - computedConstants[4] = neq(constants[1], constants[2]); - computedConstants[5] = constants[1]/neq(constants[2], constants[6]); - computedConstants[7] = lt(constants[1], constants[2]); - computedConstants[8] = constants[1]/lt(constants[2], constants[6]); - computedConstants[9] = leq(constants[1], constants[2]); - computedConstants[10] = constants[1]/leq(constants[2], constants[6]); - computedConstants[11] = gt(constants[1], constants[2]); - computedConstants[12] = constants[1]/gt(constants[2], constants[6]); - computedConstants[13] = geq(constants[1], constants[2]); - computedConstants[14] = constants[1]/geq(constants[2], constants[6]); - computedConstants[15] = and(constants[1], constants[2]); - computedConstants[16] = and(constants[1], and(constants[2], constants[6])); - computedConstants[17] = and(lt(constants[1], constants[2]), gt(constants[6], constants[18])); - computedConstants[19] = and(constants[1]+constants[2], gt(constants[6], constants[18])); - computedConstants[20] = and(constants[1], gt(constants[2], constants[6])); - computedConstants[21] = and(constants[1]-constants[2], gt(constants[6], constants[18])); - computedConstants[22] = and(-constants[1], gt(constants[2], constants[6])); - computedConstants[23] = and(pow(constants[1], constants[2]), gt(constants[6], constants[18])); - computedConstants[24] = and(pow(constants[1], 1.0/constants[2]), gt(constants[6], constants[18])); - computedConstants[25] = and(lt(constants[1], constants[2]), constants[6]+constants[18]); - computedConstants[26] = and(lt(constants[1], constants[2]), constants[6]); - computedConstants[27] = and(lt(constants[1], constants[2]), constants[6]-constants[18]); - computedConstants[28] = and(lt(constants[1], constants[2]), -constants[6]); - computedConstants[29] = and(lt(constants[1], constants[2]), pow(constants[6], constants[18])); - computedConstants[30] = and(lt(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])); - computedConstants[31] = constants[1]/and(constants[2], constants[6]); - computedConstants[32] = or(constants[1], constants[2]); - computedConstants[33] = or(constants[1], or(constants[2], constants[6])); - computedConstants[34] = or(lt(constants[1], constants[2]), gt(constants[6], constants[18])); - computedConstants[35] = or(constants[1]+constants[2], gt(constants[6], constants[18])); - computedConstants[36] = or(constants[1], gt(constants[2], constants[6])); - computedConstants[37] = or(constants[1]-constants[2], gt(constants[6], constants[18])); - computedConstants[38] = or(-constants[1], gt(constants[2], constants[6])); - computedConstants[39] = or(pow(constants[1], constants[2]), gt(constants[6], constants[18])); - computedConstants[40] = or(pow(constants[1], 1.0/constants[2]), gt(constants[6], constants[18])); - computedConstants[41] = or(lt(constants[1], constants[2]), constants[6]+constants[18]); - computedConstants[42] = or(lt(constants[1], constants[2]), constants[6]); - computedConstants[43] = or(lt(constants[1], constants[2]), constants[6]-constants[18]); - computedConstants[44] = or(lt(constants[1], constants[2]), -constants[6]); - computedConstants[45] = or(lt(constants[1], constants[2]), pow(constants[6], constants[18])); - computedConstants[46] = or(lt(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])); - computedConstants[47] = constants[1]/or(constants[2], constants[6]); - computedConstants[48] = xor(constants[1], constants[2]); - computedConstants[49] = xor(constants[1], xor(constants[2], constants[6])); - computedConstants[50] = xor(lt(constants[1], constants[2]), gt(constants[6], constants[18])); - computedConstants[51] = xor(constants[1]+constants[2], gt(constants[6], constants[18])); - computedConstants[52] = xor(constants[1], gt(constants[2], constants[6])); - computedConstants[53] = xor(constants[1]-constants[2], gt(constants[6], constants[18])); - computedConstants[54] = xor(-constants[1], gt(constants[2], constants[6])); - computedConstants[55] = xor(pow(constants[1], constants[2]), gt(constants[6], constants[18])); - computedConstants[56] = xor(pow(constants[1], 1.0/constants[2]), gt(constants[6], constants[18])); - computedConstants[57] = xor(lt(constants[1], constants[2]), constants[6]+constants[18]); - computedConstants[58] = xor(lt(constants[1], constants[2]), constants[6]); - computedConstants[59] = xor(lt(constants[1], constants[2]), constants[6]-constants[18]); - computedConstants[60] = xor(lt(constants[1], constants[2]), -constants[6]); - computedConstants[61] = xor(lt(constants[1], constants[2]), pow(constants[6], constants[18])); - computedConstants[62] = xor(lt(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])); - computedConstants[63] = constants[1]/xor(constants[2], constants[6]); - computedConstants[64] = not(constants[1]); - computedConstants[65] = constants[1]+constants[2]; - computedConstants[66] = constants[1]+constants[2]+constants[6]; - computedConstants[67] = lt(constants[1], constants[2])+gt(constants[6], constants[18]); - computedConstants[68] = constants[1]; - computedConstants[69] = constants[1]-constants[2]; - computedConstants[70] = lt(constants[1], constants[2])-gt(constants[6], constants[18]); - computedConstants[71] = lt(constants[1], constants[2])-(constants[6]+constants[18]); - computedConstants[72] = lt(constants[1], constants[2])-constants[6]; - computedConstants[73] = constants[1]-(-constants[2]); - computedConstants[74] = constants[1]-(-constants[2]*constants[6]); - computedConstants[75] = -constants[1]; - computedConstants[76] = -lt(constants[1], constants[2]); - computedConstants[77] = constants[1]*constants[2]; - computedConstants[78] = constants[1]*constants[2]*constants[6]; - computedConstants[79] = lt(constants[1], constants[2])*gt(constants[6], constants[18]); - computedConstants[80] = (constants[1]+constants[2])*gt(constants[6], constants[18]); - computedConstants[81] = constants[1]*gt(constants[2], constants[6]); - computedConstants[82] = (constants[1]-constants[2])*gt(constants[6], constants[18]); - computedConstants[83] = -constants[1]*gt(constants[2], constants[6]); - computedConstants[84] = lt(constants[1], constants[2])*(constants[6]+constants[18]); - computedConstants[85] = lt(constants[1], constants[2])*constants[6]; - computedConstants[86] = lt(constants[1], constants[2])*(constants[6]-constants[18]); - computedConstants[87] = lt(constants[1], constants[2])*-constants[6]; - computedConstants[88] = constants[1]/constants[2]; - computedConstants[89] = lt(constants[1], constants[2])/gt(constants[18], constants[6]); - computedConstants[90] = (constants[1]+constants[2])/gt(constants[18], constants[6]); - computedConstants[91] = constants[1]/gt(constants[6], constants[2]); - computedConstants[92] = (constants[1]-constants[2])/gt(constants[18], constants[6]); - computedConstants[93] = -constants[1]/gt(constants[6], constants[2]); - computedConstants[94] = lt(constants[1], constants[2])/(constants[6]+constants[18]); - computedConstants[95] = lt(constants[1], constants[2])/constants[6]; - computedConstants[96] = lt(constants[1], constants[2])/(constants[6]-constants[18]); - computedConstants[97] = lt(constants[1], constants[2])/-constants[6]; - computedConstants[98] = lt(constants[1], constants[2])/(constants[6]*constants[18]); - computedConstants[99] = lt(constants[1], constants[2])/(constants[6]/constants[18]); - computedConstants[100] = sqrt(constants[1]); - computedConstants[101] = pow(constants[1], 2.0); - computedConstants[102] = pow(constants[1], 3.0); - computedConstants[103] = pow(constants[1], constants[2]); - computedConstants[104] = pow(leq(constants[1], constants[2]), geq(constants[6], constants[18])); - computedConstants[105] = pow(constants[1]+constants[2], geq(constants[6], constants[18])); - computedConstants[106] = pow(constants[1], geq(constants[2], constants[6])); - computedConstants[107] = pow(constants[1]-constants[2], geq(constants[6], constants[18])); - computedConstants[108] = pow(-constants[1], geq(constants[2], constants[6])); - computedConstants[109] = pow(constants[1]*constants[2], geq(constants[6], constants[18])); - computedConstants[110] = pow(constants[1]/constants[2], geq(constants[6], constants[18])); - computedConstants[111] = pow(leq(constants[1], constants[2]), constants[6]+constants[18]); - computedConstants[112] = pow(leq(constants[1], constants[2]), constants[6]); - computedConstants[113] = pow(leq(constants[1], constants[2]), constants[6]-constants[18]); - computedConstants[114] = pow(leq(constants[1], constants[2]), -constants[6]); - computedConstants[115] = pow(leq(constants[1], constants[2]), constants[6]*constants[18]); - computedConstants[116] = pow(leq(constants[1], constants[2]), constants[6]/constants[18]); - computedConstants[117] = pow(leq(constants[1], constants[2]), pow(constants[6], constants[18])); - computedConstants[118] = pow(leq(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])); - computedConstants[119] = sqrt(constants[1]); - computedConstants[120] = sqrt(constants[1]); - computedConstants[121] = pow(constants[1], 1.0/3.0); - computedConstants[122] = pow(constants[1], 1.0/constants[2]); - computedConstants[123] = pow(lt(constants[1], constants[2]), 1.0/gt(constants[18], constants[6])); - computedConstants[124] = pow(constants[1]+constants[2], 1.0/gt(constants[18], constants[6])); - computedConstants[125] = pow(constants[1], 1.0/gt(constants[6], constants[2])); - computedConstants[126] = pow(constants[1]-constants[2], 1.0/gt(constants[18], constants[6])); - computedConstants[127] = pow(-constants[1], 1.0/gt(constants[6], constants[2])); - computedConstants[128] = pow(constants[1]*constants[2], 1.0/gt(constants[18], constants[6])); - computedConstants[129] = pow(constants[1]/constants[2], 1.0/gt(constants[18], constants[6])); - computedConstants[130] = pow(lt(constants[1], constants[2]), 1.0/(constants[6]+constants[18])); - computedConstants[131] = pow(lt(constants[1], constants[2]), 1.0/constants[6]); - computedConstants[132] = pow(lt(constants[1], constants[2]), 1.0/(constants[6]-constants[18])); - computedConstants[133] = pow(lt(constants[1], constants[2]), 1.0/-constants[6]); - computedConstants[134] = pow(lt(constants[1], constants[2]), 1.0/(constants[6]*constants[18])); - computedConstants[135] = pow(lt(constants[1], constants[2]), 1.0/(constants[6]/constants[18])); - computedConstants[136] = pow(lt(constants[1], constants[2]), 1.0/pow(constants[6], constants[18])); - computedConstants[137] = pow(lt(constants[1], constants[2]), 1.0/pow(constants[6], 1.0/constants[18])); - computedConstants[138] = fabs(constants[1]); - computedConstants[139] = exp(constants[1]); - computedConstants[140] = log(constants[1]); - computedConstants[141] = log10(constants[1]); - computedConstants[142] = log(constants[1])/log(2.0); - computedConstants[143] = log10(constants[1]); - computedConstants[144] = log(constants[1])/log(constants[2]); - computedConstants[145] = ceil(constants[1]); - computedConstants[146] = floor(constants[1]); - computedConstants[147] = min(constants[1], constants[2]); - computedConstants[148] = min(constants[1], min(constants[2], constants[6])); - computedConstants[149] = max(constants[1], constants[2]); - computedConstants[150] = max(constants[1], max(constants[2], constants[6])); - computedConstants[151] = fmod(constants[1], constants[2]); - computedConstants[152] = sin(constants[1]); - computedConstants[153] = cos(constants[1]); - computedConstants[154] = tan(constants[1]); - computedConstants[155] = sec(constants[1]); - computedConstants[156] = csc(constants[1]); - computedConstants[157] = cot(constants[1]); - computedConstants[158] = sinh(constants[1]); - computedConstants[159] = cosh(constants[1]); - computedConstants[160] = tanh(constants[1]); - computedConstants[161] = sech(constants[1]); - computedConstants[162] = csch(constants[1]); - computedConstants[163] = coth(constants[1]); - computedConstants[164] = asin(constants[1]); - computedConstants[165] = acos(constants[1]); - computedConstants[166] = atan(constants[1]); - computedConstants[167] = asec(constants[1]); - computedConstants[168] = acsc(constants[1]); - computedConstants[169] = acot(constants[1]); - computedConstants[170] = asinh(constants[1]); - computedConstants[171] = acosh(constants[1]); - computedConstants[172] = atanh(constants[1]/2.0); - computedConstants[173] = asech(constants[1]); - computedConstants[174] = acsch(constants[1]); - computedConstants[175] = acoth(2.0*constants[1]); - computedConstants[176] = (gt(constants[1], constants[2]))?constants[1]:NAN; - computedConstants[177] = (gt(constants[1], constants[2]))?constants[1]:constants[6]; - computedConstants[178] = (gt(constants[1], constants[2]))?constants[1]:(gt(constants[6], constants[18]))?constants[6]:(gt(constants[179], constants[180]))?constants[179]:NAN; - computedConstants[181] = (gt(constants[1], constants[2]))?constants[1]:(gt(constants[6], constants[18]))?constants[6]:(gt(constants[179], constants[180]))?constants[179]:constants[182]; - computedConstants[183] = 123.0+((gt(constants[1], constants[2]))?constants[1]:NAN); - computedConstants[188] = constants[1]; - computedConstants[195] = and(constants[1], constants[2])+((gt(constants[6], constants[18]))?constants[2]:NAN)+constants[179]+and(constants[180], constants[182]); - computedConstants[196] = and(constants[1], constants[2])-(((gt(constants[6], constants[18]))?constants[2]:NAN)-(constants[179]-((gt(constants[6], constants[18]))?constants[2]:NAN)))-and(constants[180], constants[182]); - computedConstants[197] = and(constants[1], constants[2])*((gt(constants[6], constants[18]))?constants[2]:NAN)*constants[179]*((gt(constants[6], constants[18]))?constants[2]:NAN)*and(constants[180], constants[182]); - computedConstants[198] = and(constants[1], constants[2])/(((gt(constants[6], constants[18]))?constants[2]:NAN)/(constants[179]/((gt(constants[6], constants[18]))?constants[2]:NAN))); - computedConstants[199] = and(or(constants[1], constants[2]), and(xor(constants[1], constants[2]), and((gt(constants[6], constants[18]))?constants[2]:NAN, and(and(and(constants[179], (gt(constants[6], constants[18]))?constants[2]:NAN), xor(constants[1], constants[2])), or(constants[1], constants[2]))))); - computedConstants[200] = or(and(constants[1], constants[2]), or(xor(constants[1], constants[2]), or((gt(constants[6], constants[18]))?constants[2]:NAN, or(or(or(constants[179], (gt(constants[6], constants[18]))?constants[2]:NAN), xor(constants[1], constants[2])), and(constants[1], constants[2]))))); - computedConstants[201] = xor(and(constants[1], constants[2]), xor(or(constants[1], constants[2]), xor((gt(constants[6], constants[18]))?constants[2]:NAN, xor(xor(xor(constants[179], (gt(constants[6], constants[18]))?constants[2]:NAN), or(constants[1], constants[2])), and(constants[1], constants[2]))))); - computedConstants[202] = pow(and(constants[1], constants[2]), pow((gt(constants[6], constants[18]))?constants[2]:NAN, pow(pow(constants[179], (gt(constants[6], constants[18]))?constants[2]:NAN), and(constants[1], constants[2])))); - computedConstants[203] = pow(pow(pow(and(constants[1], constants[2]), 1.0/pow((gt(constants[6], constants[18]))?constants[2]:NAN, 1.0/constants[179])), 1.0/((gt(constants[6], constants[18]))?constants[2]:NAN)), 1.0/and(constants[1], constants[2])); - computedConstants[204] = -and(constants[1], constants[2])+-((gt(constants[6], constants[18]))?constants[2]:NAN); + computedConstants[0] = eq(constants[0], constants[1]); + computedConstants[1] = constants[0]/eq(constants[1], constants[1]); + computedConstants[2] = neq(constants[0], constants[1]); + computedConstants[3] = constants[0]/neq(constants[1], constants[2]); + computedConstants[4] = lt(constants[0], constants[1]); + computedConstants[5] = constants[0]/lt(constants[1], constants[2]); + computedConstants[6] = leq(constants[0], constants[1]); + computedConstants[7] = constants[0]/leq(constants[1], constants[2]); + computedConstants[8] = gt(constants[0], constants[1]); + computedConstants[9] = constants[0]/gt(constants[1], constants[2]); + computedConstants[10] = geq(constants[0], constants[1]); + computedConstants[11] = constants[0]/geq(constants[1], constants[2]); + computedConstants[12] = and(constants[0], constants[1]); + computedConstants[13] = and(constants[0], and(constants[1], constants[2])); + computedConstants[14] = and(lt(constants[0], constants[1]), gt(constants[2], constants[3])); + computedConstants[15] = and(constants[0]+constants[1], gt(constants[2], constants[3])); + computedConstants[16] = and(constants[0], gt(constants[1], constants[2])); + computedConstants[17] = and(constants[0]-constants[1], gt(constants[2], constants[3])); + computedConstants[18] = and(-constants[0], gt(constants[1], constants[2])); + computedConstants[19] = and(pow(constants[0], constants[1]), gt(constants[2], constants[3])); + computedConstants[20] = and(pow(constants[0], 1.0/constants[1]), gt(constants[2], constants[3])); + computedConstants[21] = and(lt(constants[0], constants[1]), constants[2]+constants[3]); + computedConstants[22] = and(lt(constants[0], constants[1]), constants[2]); + computedConstants[23] = and(lt(constants[0], constants[1]), constants[2]-constants[3]); + computedConstants[24] = and(lt(constants[0], constants[1]), -constants[2]); + computedConstants[25] = and(lt(constants[0], constants[1]), pow(constants[2], constants[3])); + computedConstants[26] = and(lt(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])); + computedConstants[27] = constants[0]/and(constants[1], constants[2]); + computedConstants[28] = or(constants[0], constants[1]); + computedConstants[29] = or(constants[0], or(constants[1], constants[2])); + computedConstants[30] = or(lt(constants[0], constants[1]), gt(constants[2], constants[3])); + computedConstants[31] = or(constants[0]+constants[1], gt(constants[2], constants[3])); + computedConstants[32] = or(constants[0], gt(constants[1], constants[2])); + computedConstants[33] = or(constants[0]-constants[1], gt(constants[2], constants[3])); + computedConstants[34] = or(-constants[0], gt(constants[1], constants[2])); + computedConstants[35] = or(pow(constants[0], constants[1]), gt(constants[2], constants[3])); + computedConstants[36] = or(pow(constants[0], 1.0/constants[1]), gt(constants[2], constants[3])); + computedConstants[37] = or(lt(constants[0], constants[1]), constants[2]+constants[3]); + computedConstants[38] = or(lt(constants[0], constants[1]), constants[2]); + computedConstants[39] = or(lt(constants[0], constants[1]), constants[2]-constants[3]); + computedConstants[40] = or(lt(constants[0], constants[1]), -constants[2]); + computedConstants[41] = or(lt(constants[0], constants[1]), pow(constants[2], constants[3])); + computedConstants[42] = or(lt(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])); + computedConstants[43] = constants[0]/or(constants[1], constants[2]); + computedConstants[44] = xor(constants[0], constants[1]); + computedConstants[45] = xor(constants[0], xor(constants[1], constants[2])); + computedConstants[46] = xor(lt(constants[0], constants[1]), gt(constants[2], constants[3])); + computedConstants[47] = xor(constants[0]+constants[1], gt(constants[2], constants[3])); + computedConstants[48] = xor(constants[0], gt(constants[1], constants[2])); + computedConstants[49] = xor(constants[0]-constants[1], gt(constants[2], constants[3])); + computedConstants[50] = xor(-constants[0], gt(constants[1], constants[2])); + computedConstants[51] = xor(pow(constants[0], constants[1]), gt(constants[2], constants[3])); + computedConstants[52] = xor(pow(constants[0], 1.0/constants[1]), gt(constants[2], constants[3])); + computedConstants[53] = xor(lt(constants[0], constants[1]), constants[2]+constants[3]); + computedConstants[54] = xor(lt(constants[0], constants[1]), constants[2]); + computedConstants[55] = xor(lt(constants[0], constants[1]), constants[2]-constants[3]); + computedConstants[56] = xor(lt(constants[0], constants[1]), -constants[2]); + computedConstants[57] = xor(lt(constants[0], constants[1]), pow(constants[2], constants[3])); + computedConstants[58] = xor(lt(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[0]/xor(constants[1], constants[2]); + computedConstants[60] = not(constants[0]); + computedConstants[61] = constants[0]+constants[1]; + computedConstants[62] = constants[0]+constants[1]+constants[2]; + computedConstants[63] = lt(constants[0], constants[1])+gt(constants[2], constants[3]); + computedConstants[64] = constants[0]; + computedConstants[65] = constants[0]-constants[1]; + computedConstants[66] = lt(constants[0], constants[1])-gt(constants[2], constants[3]); + computedConstants[67] = lt(constants[0], constants[1])-(constants[2]+constants[3]); + computedConstants[68] = lt(constants[0], constants[1])-constants[2]; + computedConstants[69] = constants[0]-(-constants[1]); + computedConstants[70] = constants[0]-(-constants[1]*constants[2]); + computedConstants[71] = -constants[0]; + computedConstants[72] = -lt(constants[0], constants[1]); + computedConstants[73] = constants[0]*constants[1]; + computedConstants[74] = constants[0]*constants[1]*constants[2]; + computedConstants[75] = lt(constants[0], constants[1])*gt(constants[2], constants[3]); + computedConstants[76] = (constants[0]+constants[1])*gt(constants[2], constants[3]); + computedConstants[77] = constants[0]*gt(constants[1], constants[2]); + computedConstants[78] = (constants[0]-constants[1])*gt(constants[2], constants[3]); + computedConstants[79] = -constants[0]*gt(constants[1], constants[2]); + computedConstants[80] = lt(constants[0], constants[1])*(constants[2]+constants[3]); + computedConstants[81] = lt(constants[0], constants[1])*constants[2]; + computedConstants[82] = lt(constants[0], constants[1])*(constants[2]-constants[3]); + computedConstants[83] = lt(constants[0], constants[1])*-constants[2]; + computedConstants[84] = constants[0]/constants[1]; + computedConstants[85] = lt(constants[0], constants[1])/gt(constants[3], constants[2]); + computedConstants[86] = (constants[0]+constants[1])/gt(constants[3], constants[2]); + computedConstants[87] = constants[0]/gt(constants[2], constants[1]); + computedConstants[88] = (constants[0]-constants[1])/gt(constants[3], constants[2]); + computedConstants[89] = -constants[0]/gt(constants[2], constants[1]); + computedConstants[90] = lt(constants[0], constants[1])/(constants[2]+constants[3]); + computedConstants[91] = lt(constants[0], constants[1])/constants[2]; + computedConstants[92] = lt(constants[0], constants[1])/(constants[2]-constants[3]); + computedConstants[93] = lt(constants[0], constants[1])/-constants[2]; + computedConstants[94] = lt(constants[0], constants[1])/(constants[2]*constants[3]); + computedConstants[95] = lt(constants[0], constants[1])/(constants[2]/constants[3]); + computedConstants[96] = sqrt(constants[0]); + computedConstants[97] = pow(constants[0], 2.0); + computedConstants[98] = pow(constants[0], 3.0); + computedConstants[99] = pow(constants[0], constants[1]); + computedConstants[100] = pow(leq(constants[0], constants[1]), geq(constants[2], constants[3])); + computedConstants[101] = pow(constants[0]+constants[1], geq(constants[2], constants[3])); + computedConstants[102] = pow(constants[0], geq(constants[1], constants[2])); + computedConstants[103] = pow(constants[0]-constants[1], geq(constants[2], constants[3])); + computedConstants[104] = pow(-constants[0], geq(constants[1], constants[2])); + computedConstants[105] = pow(constants[0]*constants[1], geq(constants[2], constants[3])); + computedConstants[106] = pow(constants[0]/constants[1], geq(constants[2], constants[3])); + computedConstants[107] = pow(leq(constants[0], constants[1]), constants[2]+constants[3]); + computedConstants[108] = pow(leq(constants[0], constants[1]), constants[2]); + computedConstants[109] = pow(leq(constants[0], constants[1]), constants[2]-constants[3]); + computedConstants[110] = pow(leq(constants[0], constants[1]), -constants[2]); + computedConstants[111] = pow(leq(constants[0], constants[1]), constants[2]*constants[3]); + computedConstants[112] = pow(leq(constants[0], constants[1]), constants[2]/constants[3]); + computedConstants[113] = pow(leq(constants[0], constants[1]), pow(constants[2], constants[3])); + computedConstants[114] = pow(leq(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])); + computedConstants[115] = sqrt(constants[0]); + computedConstants[116] = sqrt(constants[0]); + computedConstants[117] = pow(constants[0], 1.0/3.0); + computedConstants[118] = pow(constants[0], 1.0/constants[1]); + computedConstants[119] = pow(lt(constants[0], constants[1]), 1.0/gt(constants[3], constants[2])); + computedConstants[120] = pow(constants[0]+constants[1], 1.0/gt(constants[3], constants[2])); + computedConstants[121] = pow(constants[0], 1.0/gt(constants[2], constants[1])); + computedConstants[122] = pow(constants[0]-constants[1], 1.0/gt(constants[3], constants[2])); + computedConstants[123] = pow(-constants[0], 1.0/gt(constants[2], constants[1])); + computedConstants[124] = pow(constants[0]*constants[1], 1.0/gt(constants[3], constants[2])); + computedConstants[125] = pow(constants[0]/constants[1], 1.0/gt(constants[3], constants[2])); + computedConstants[126] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]+constants[3])); + computedConstants[127] = pow(lt(constants[0], constants[1]), 1.0/constants[2]); + computedConstants[128] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]-constants[3])); + computedConstants[129] = pow(lt(constants[0], constants[1]), 1.0/-constants[2]); + computedConstants[130] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]*constants[3])); + computedConstants[131] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]/constants[3])); + computedConstants[132] = pow(lt(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])); + computedConstants[133] = pow(lt(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[134] = fabs(constants[0]); + computedConstants[135] = exp(constants[0]); + computedConstants[136] = log(constants[0]); + computedConstants[137] = log10(constants[0]); + computedConstants[138] = log(constants[0])/log(2.0); + computedConstants[139] = log10(constants[0]); + computedConstants[140] = log(constants[0])/log(constants[1]); + computedConstants[141] = ceil(constants[0]); + computedConstants[142] = floor(constants[0]); + computedConstants[143] = min(constants[0], constants[1]); + computedConstants[144] = min(constants[0], min(constants[1], constants[2])); + computedConstants[145] = max(constants[0], constants[1]); + computedConstants[146] = max(constants[0], max(constants[1], constants[2])); + computedConstants[147] = fmod(constants[0], constants[1]); + computedConstants[148] = sin(constants[0]); + computedConstants[149] = cos(constants[0]); + computedConstants[150] = tan(constants[0]); + computedConstants[151] = sec(constants[0]); + computedConstants[152] = csc(constants[0]); + computedConstants[153] = cot(constants[0]); + computedConstants[154] = sinh(constants[0]); + computedConstants[155] = cosh(constants[0]); + computedConstants[156] = tanh(constants[0]); + computedConstants[157] = sech(constants[0]); + computedConstants[158] = csch(constants[0]); + computedConstants[159] = coth(constants[0]); + computedConstants[160] = asin(constants[0]); + computedConstants[161] = acos(constants[0]); + computedConstants[162] = atan(constants[0]); + computedConstants[163] = asec(constants[0]); + computedConstants[164] = acsc(constants[0]); + computedConstants[165] = acot(constants[0]); + computedConstants[166] = asinh(constants[0]); + computedConstants[167] = acosh(constants[0]); + computedConstants[168] = atanh(constants[0]/2.0); + computedConstants[169] = asech(constants[0]); + computedConstants[170] = acsch(constants[0]); + computedConstants[171] = acoth(2.0*constants[0]); + computedConstants[172] = (gt(constants[0], constants[1]))?constants[0]:NAN; + computedConstants[173] = (gt(constants[0], constants[1]))?constants[0]:constants[2]; + computedConstants[174] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:NAN; + computedConstants[175] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:constants[6]; + computedConstants[176] = 123.0+((gt(constants[0], constants[1]))?constants[0]:NAN); + computedConstants[181] = constants[0]; + computedConstants[188] = and(constants[0], constants[1])+((gt(constants[2], constants[3]))?constants[1]:NAN)+constants[4]+and(constants[5], constants[6]); + computedConstants[189] = and(constants[0], constants[1])-(((gt(constants[2], constants[3]))?constants[1]:NAN)-(constants[4]-((gt(constants[2], constants[3]))?constants[1]:NAN)))-and(constants[5], constants[6]); + computedConstants[190] = and(constants[0], constants[1])*((gt(constants[2], constants[3]))?constants[1]:NAN)*constants[4]*((gt(constants[2], constants[3]))?constants[1]:NAN)*and(constants[5], constants[6]); + computedConstants[191] = and(constants[0], constants[1])/(((gt(constants[2], constants[3]))?constants[1]:NAN)/(constants[4]/((gt(constants[2], constants[3]))?constants[1]:NAN))); + computedConstants[192] = and(or(constants[0], constants[1]), and(xor(constants[0], constants[1]), and((gt(constants[2], constants[3]))?constants[1]:NAN, and(and(and(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), xor(constants[0], constants[1])), or(constants[0], constants[1]))))); + computedConstants[193] = or(and(constants[0], constants[1]), or(xor(constants[0], constants[1]), or((gt(constants[2], constants[3]))?constants[1]:NAN, or(or(or(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), xor(constants[0], constants[1])), and(constants[0], constants[1]))))); + computedConstants[194] = xor(and(constants[0], constants[1]), xor(or(constants[0], constants[1]), xor((gt(constants[2], constants[3]))?constants[1]:NAN, xor(xor(xor(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), or(constants[0], constants[1])), and(constants[0], constants[1]))))); + computedConstants[195] = pow(and(constants[0], constants[1]), pow((gt(constants[2], constants[3]))?constants[1]:NAN, pow(pow(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), and(constants[0], constants[1])))); + computedConstants[196] = pow(pow(pow(and(constants[0], constants[1]), 1.0/pow((gt(constants[2], constants[3]))?constants[1]:NAN, 1.0/constants[4])), 1.0/((gt(constants[2], constants[3]))?constants[1]:NAN)), 1.0/and(constants[0], constants[1])); + computedConstants[197] = -and(constants[0], constants[1])+-((gt(constants[2], constants[3]))?constants[1]:NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index b5bd90746..986e59821 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -356,11 +356,11 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[205] = u[0]; - algebraic[206] = u[1]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; - f[0] = algebraic[205]+algebraic[206]+states[0]-0.0; - f[1] = algebraic[205]-algebraic[206]-(computedConstants[207]+computedConstants[208]); + f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; + f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -368,231 +368,231 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[2]; - u[0] = algebraic[205]; - u[1] = algebraic[206]; + u[0] = algebraic[0]; + u[1] = algebraic[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[205] = u[0]; - algebraic[206] = u[1]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; } void initialiseVariables(double *states, double *rates, double *constants) { - constants[1] = 1.0; - constants[2] = 2.0; - constants[6] = 3.0; - constants[18] = 4.0; - constants[179] = 5.0; - constants[180] = 6.0; - constants[182] = 7.0; - algebraic[205] = 1.0; - algebraic[206] = 2.0; - computedConstants[184] = 123.0; - computedConstants[185] = 123.456789; - computedConstants[186] = 123.0e99; - computedConstants[187] = 123.456789e99; - computedConstants[189] = 1.0; - computedConstants[190] = 0.0; - computedConstants[191] = 2.71828182845905; - computedConstants[192] = 3.14159265358979; - computedConstants[193] = INFINITY; - computedConstants[194] = NAN; - computedConstants[207] = 1.0; - computedConstants[208] = 3.0; + constants[0] = 1.0; + constants[1] = 2.0; + constants[2] = 3.0; + constants[3] = 4.0; + constants[4] = 5.0; + constants[5] = 6.0; + constants[6] = 7.0; + algebraic[0] = 1.0; + algebraic[1] = 2.0; + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = constants[1] == constants[2]; - computedConstants[3] = constants[1]/(constants[2] == constants[2]); - computedConstants[4] = constants[1] != constants[2]; - computedConstants[5] = constants[1]/(constants[2] != constants[6]); - computedConstants[7] = constants[1] < constants[2]; - computedConstants[8] = constants[1]/(constants[2] < constants[6]); - computedConstants[9] = constants[1] <= constants[2]; - computedConstants[10] = constants[1]/(constants[2] <= constants[6]); - computedConstants[11] = constants[1] > constants[2]; - computedConstants[12] = constants[1]/(constants[2] > constants[6]); - computedConstants[13] = constants[1] >= constants[2]; - computedConstants[14] = constants[1]/(constants[2] >= constants[6]); - computedConstants[15] = constants[1] && constants[2]; - computedConstants[16] = constants[1] && constants[2] && constants[6]; - computedConstants[17] = (constants[1] < constants[2]) && (constants[6] > constants[18]); - computedConstants[19] = (constants[1]+constants[2]) && (constants[6] > constants[18]); - computedConstants[20] = constants[1] && (constants[2] > constants[6]); - computedConstants[21] = (constants[1]-constants[2]) && (constants[6] > constants[18]); - computedConstants[22] = -constants[1] && (constants[2] > constants[6]); - computedConstants[23] = pow(constants[1], constants[2]) && (constants[6] > constants[18]); - computedConstants[24] = pow(constants[1], 1.0/constants[2]) && (constants[6] > constants[18]); - computedConstants[25] = (constants[1] < constants[2]) && (constants[6]+constants[18]); - computedConstants[26] = (constants[1] < constants[2]) && constants[6]; - computedConstants[27] = (constants[1] < constants[2]) && (constants[6]-constants[18]); - computedConstants[28] = (constants[1] < constants[2]) && -constants[6]; - computedConstants[29] = (constants[1] < constants[2]) && pow(constants[6], constants[18]); - computedConstants[30] = (constants[1] < constants[2]) && pow(constants[6], 1.0/constants[18]); - computedConstants[31] = constants[1]/(constants[2] && constants[6]); - computedConstants[32] = constants[1] || constants[2]; - computedConstants[33] = constants[1] || constants[2] || constants[6]; - computedConstants[34] = (constants[1] < constants[2]) || (constants[6] > constants[18]); - computedConstants[35] = (constants[1]+constants[2]) || (constants[6] > constants[18]); - computedConstants[36] = constants[1] || (constants[2] > constants[6]); - computedConstants[37] = (constants[1]-constants[2]) || (constants[6] > constants[18]); - computedConstants[38] = -constants[1] || (constants[2] > constants[6]); - computedConstants[39] = pow(constants[1], constants[2]) || (constants[6] > constants[18]); - computedConstants[40] = pow(constants[1], 1.0/constants[2]) || (constants[6] > constants[18]); - computedConstants[41] = (constants[1] < constants[2]) || (constants[6]+constants[18]); - computedConstants[42] = (constants[1] < constants[2]) || constants[6]; - computedConstants[43] = (constants[1] < constants[2]) || (constants[6]-constants[18]); - computedConstants[44] = (constants[1] < constants[2]) || -constants[6]; - computedConstants[45] = (constants[1] < constants[2]) || pow(constants[6], constants[18]); - computedConstants[46] = (constants[1] < constants[2]) || pow(constants[6], 1.0/constants[18]); - computedConstants[47] = constants[1]/(constants[2] || constants[6]); - computedConstants[48] = xor(constants[1], constants[2]); - computedConstants[49] = xor(constants[1], xor(constants[2], constants[6])); - computedConstants[50] = xor(constants[1] < constants[2], constants[6] > constants[18]); - computedConstants[51] = xor(constants[1]+constants[2], constants[6] > constants[18]); - computedConstants[52] = xor(constants[1], constants[2] > constants[6]); - computedConstants[53] = xor(constants[1]-constants[2], constants[6] > constants[18]); - computedConstants[54] = xor(-constants[1], constants[2] > constants[6]); - computedConstants[55] = xor(pow(constants[1], constants[2]), constants[6] > constants[18]); - computedConstants[56] = xor(pow(constants[1], 1.0/constants[2]), constants[6] > constants[18]); - computedConstants[57] = xor(constants[1] < constants[2], constants[6]+constants[18]); - computedConstants[58] = xor(constants[1] < constants[2], constants[6]); - computedConstants[59] = xor(constants[1] < constants[2], constants[6]-constants[18]); - computedConstants[60] = xor(constants[1] < constants[2], -constants[6]); - computedConstants[61] = xor(constants[1] < constants[2], pow(constants[6], constants[18])); - computedConstants[62] = xor(constants[1] < constants[2], pow(constants[6], 1.0/constants[18])); - computedConstants[63] = constants[1]/xor(constants[2], constants[6]); - computedConstants[64] = !constants[1]; - computedConstants[65] = constants[1]+constants[2]; - computedConstants[66] = constants[1]+constants[2]+constants[6]; - computedConstants[67] = (constants[1] < constants[2])+(constants[6] > constants[18]); - computedConstants[68] = constants[1]; - computedConstants[69] = constants[1]-constants[2]; - computedConstants[70] = (constants[1] < constants[2])-(constants[6] > constants[18]); - computedConstants[71] = (constants[1] < constants[2])-(constants[6]+constants[18]); - computedConstants[72] = (constants[1] < constants[2])-constants[6]; - computedConstants[73] = constants[1]-(-constants[2]); - computedConstants[74] = constants[1]-(-constants[2]*constants[6]); - computedConstants[75] = -constants[1]; - computedConstants[76] = -(constants[1] < constants[2]); - computedConstants[77] = constants[1]*constants[2]; - computedConstants[78] = constants[1]*constants[2]*constants[6]; - computedConstants[79] = (constants[1] < constants[2])*(constants[6] > constants[18]); - computedConstants[80] = (constants[1]+constants[2])*(constants[6] > constants[18]); - computedConstants[81] = constants[1]*(constants[2] > constants[6]); - computedConstants[82] = (constants[1]-constants[2])*(constants[6] > constants[18]); - computedConstants[83] = -constants[1]*(constants[2] > constants[6]); - computedConstants[84] = (constants[1] < constants[2])*(constants[6]+constants[18]); - computedConstants[85] = (constants[1] < constants[2])*constants[6]; - computedConstants[86] = (constants[1] < constants[2])*(constants[6]-constants[18]); - computedConstants[87] = (constants[1] < constants[2])*-constants[6]; - computedConstants[88] = constants[1]/constants[2]; - computedConstants[89] = (constants[1] < constants[2])/(constants[18] > constants[6]); - computedConstants[90] = (constants[1]+constants[2])/(constants[18] > constants[6]); - computedConstants[91] = constants[1]/(constants[6] > constants[2]); - computedConstants[92] = (constants[1]-constants[2])/(constants[18] > constants[6]); - computedConstants[93] = -constants[1]/(constants[6] > constants[2]); - computedConstants[94] = (constants[1] < constants[2])/(constants[6]+constants[18]); - computedConstants[95] = (constants[1] < constants[2])/constants[6]; - computedConstants[96] = (constants[1] < constants[2])/(constants[6]-constants[18]); - computedConstants[97] = (constants[1] < constants[2])/-constants[6]; - computedConstants[98] = (constants[1] < constants[2])/(constants[6]*constants[18]); - computedConstants[99] = (constants[1] < constants[2])/(constants[6]/constants[18]); - computedConstants[100] = sqrt(constants[1]); - computedConstants[101] = pow(constants[1], 2.0); - computedConstants[102] = pow(constants[1], 3.0); - computedConstants[103] = pow(constants[1], constants[2]); - computedConstants[104] = pow(constants[1] <= constants[2], constants[6] >= constants[18]); - computedConstants[105] = pow(constants[1]+constants[2], constants[6] >= constants[18]); - computedConstants[106] = pow(constants[1], constants[2] >= constants[6]); - computedConstants[107] = pow(constants[1]-constants[2], constants[6] >= constants[18]); - computedConstants[108] = pow(-constants[1], constants[2] >= constants[6]); - computedConstants[109] = pow(constants[1]*constants[2], constants[6] >= constants[18]); - computedConstants[110] = pow(constants[1]/constants[2], constants[6] >= constants[18]); - computedConstants[111] = pow(constants[1] <= constants[2], constants[6]+constants[18]); - computedConstants[112] = pow(constants[1] <= constants[2], constants[6]); - computedConstants[113] = pow(constants[1] <= constants[2], constants[6]-constants[18]); - computedConstants[114] = pow(constants[1] <= constants[2], -constants[6]); - computedConstants[115] = pow(constants[1] <= constants[2], constants[6]*constants[18]); - computedConstants[116] = pow(constants[1] <= constants[2], constants[6]/constants[18]); - computedConstants[117] = pow(constants[1] <= constants[2], pow(constants[6], constants[18])); - computedConstants[118] = pow(constants[1] <= constants[2], pow(constants[6], 1.0/constants[18])); - computedConstants[119] = sqrt(constants[1]); - computedConstants[120] = sqrt(constants[1]); - computedConstants[121] = pow(constants[1], 1.0/3.0); - computedConstants[122] = pow(constants[1], 1.0/constants[2]); - computedConstants[123] = pow(constants[1] < constants[2], 1.0/(constants[18] > constants[6])); - computedConstants[124] = pow(constants[1]+constants[2], 1.0/(constants[18] > constants[6])); - computedConstants[125] = pow(constants[1], 1.0/(constants[6] > constants[2])); - computedConstants[126] = pow(constants[1]-constants[2], 1.0/(constants[18] > constants[6])); - computedConstants[127] = pow(-constants[1], 1.0/(constants[6] > constants[2])); - computedConstants[128] = pow(constants[1]*constants[2], 1.0/(constants[18] > constants[6])); - computedConstants[129] = pow(constants[1]/constants[2], 1.0/(constants[18] > constants[6])); - computedConstants[130] = pow(constants[1] < constants[2], 1.0/(constants[6]+constants[18])); - computedConstants[131] = pow(constants[1] < constants[2], 1.0/constants[6]); - computedConstants[132] = pow(constants[1] < constants[2], 1.0/(constants[6]-constants[18])); - computedConstants[133] = pow(constants[1] < constants[2], 1.0/-constants[6]); - computedConstants[134] = pow(constants[1] < constants[2], 1.0/(constants[6]*constants[18])); - computedConstants[135] = pow(constants[1] < constants[2], 1.0/(constants[6]/constants[18])); - computedConstants[136] = pow(constants[1] < constants[2], 1.0/pow(constants[6], constants[18])); - computedConstants[137] = pow(constants[1] < constants[2], 1.0/pow(constants[6], 1.0/constants[18])); - computedConstants[138] = fabs(constants[1]); - computedConstants[139] = exp(constants[1]); - computedConstants[140] = log(constants[1]); - computedConstants[141] = log10(constants[1]); - computedConstants[142] = log(constants[1])/log(2.0); - computedConstants[143] = log10(constants[1]); - computedConstants[144] = log(constants[1])/log(constants[2]); - computedConstants[145] = ceil(constants[1]); - computedConstants[146] = floor(constants[1]); - computedConstants[147] = min(constants[1], constants[2]); - computedConstants[148] = min(constants[1], min(constants[2], constants[6])); - computedConstants[149] = max(constants[1], constants[2]); - computedConstants[150] = max(constants[1], max(constants[2], constants[6])); - computedConstants[151] = fmod(constants[1], constants[2]); - computedConstants[152] = sin(constants[1]); - computedConstants[153] = cos(constants[1]); - computedConstants[154] = tan(constants[1]); - computedConstants[155] = sec(constants[1]); - computedConstants[156] = csc(constants[1]); - computedConstants[157] = cot(constants[1]); - computedConstants[158] = sinh(constants[1]); - computedConstants[159] = cosh(constants[1]); - computedConstants[160] = tanh(constants[1]); - computedConstants[161] = sech(constants[1]); - computedConstants[162] = csch(constants[1]); - computedConstants[163] = coth(constants[1]); - computedConstants[164] = asin(constants[1]); - computedConstants[165] = acos(constants[1]); - computedConstants[166] = atan(constants[1]); - computedConstants[167] = asec(constants[1]); - computedConstants[168] = acsc(constants[1]); - computedConstants[169] = acot(constants[1]); - computedConstants[170] = asinh(constants[1]); - computedConstants[171] = acosh(constants[1]); - computedConstants[172] = atanh(constants[1]/2.0); - computedConstants[173] = asech(constants[1]); - computedConstants[174] = acsch(constants[1]); - computedConstants[175] = acoth(2.0*constants[1]); - computedConstants[176] = (constants[1] > constants[2])?constants[1]:NAN; - computedConstants[177] = (constants[1] > constants[2])?constants[1]:constants[6]; - computedConstants[178] = (constants[1] > constants[2])?constants[1]:(constants[6] > constants[18])?constants[6]:(constants[179] > constants[180])?constants[179]:NAN; - computedConstants[181] = (constants[1] > constants[2])?constants[1]:(constants[6] > constants[18])?constants[6]:(constants[179] > constants[180])?constants[179]:constants[182]; - computedConstants[183] = 123.0+((constants[1] > constants[2])?constants[1]:NAN); - computedConstants[188] = constants[1]; - computedConstants[195] = (constants[1] && constants[2])+((constants[6] > constants[18])?constants[2]:NAN)+constants[179]+(constants[180] && constants[182]); - computedConstants[196] = (constants[1] && constants[2])-(((constants[6] > constants[18])?constants[2]:NAN)-(constants[179]-((constants[6] > constants[18])?constants[2]:NAN)))-(constants[180] && constants[182]); - computedConstants[197] = (constants[1] && constants[2])*((constants[6] > constants[18])?constants[2]:NAN)*constants[179]*((constants[6] > constants[18])?constants[2]:NAN)*(constants[180] && constants[182]); - computedConstants[198] = (constants[1] && constants[2])/(((constants[6] > constants[18])?constants[2]:NAN)/(constants[179]/((constants[6] > constants[18])?constants[2]:NAN))); - computedConstants[199] = (constants[1] || constants[2]) && xor(constants[1], constants[2]) && ((constants[6] > constants[18])?constants[2]:NAN) && constants[179] && ((constants[6] > constants[18])?constants[2]:NAN) && xor(constants[1], constants[2]) && (constants[1] || constants[2]); - computedConstants[200] = (constants[1] && constants[2]) || xor(constants[1], constants[2]) || ((constants[6] > constants[18])?constants[2]:NAN) || constants[179] || ((constants[6] > constants[18])?constants[2]:NAN) || xor(constants[1], constants[2]) || (constants[1] && constants[2]); - computedConstants[201] = xor(constants[1] && constants[2], xor(constants[1] || constants[2], xor((constants[6] > constants[18])?constants[2]:NAN, xor(xor(xor(constants[179], (constants[6] > constants[18])?constants[2]:NAN), constants[1] || constants[2]), constants[1] && constants[2])))); - computedConstants[202] = pow(constants[1] && constants[2], pow((constants[6] > constants[18])?constants[2]:NAN, pow(pow(constants[179], (constants[6] > constants[18])?constants[2]:NAN), constants[1] && constants[2]))); - computedConstants[203] = pow(pow(pow(constants[1] && constants[2], 1.0/pow((constants[6] > constants[18])?constants[2]:NAN, 1.0/constants[179])), 1.0/((constants[6] > constants[18])?constants[2]:NAN)), 1.0/(constants[1] && constants[2])); - computedConstants[204] = -(constants[1] && constants[2])+-((constants[6] > constants[18])?constants[2]:NAN); + computedConstants[0] = constants[0] == constants[1]; + computedConstants[1] = constants[0]/(constants[1] == constants[1]); + computedConstants[2] = constants[0] != constants[1]; + computedConstants[3] = constants[0]/(constants[1] != constants[2]); + computedConstants[4] = constants[0] < constants[1]; + computedConstants[5] = constants[0]/(constants[1] < constants[2]); + computedConstants[6] = constants[0] <= constants[1]; + computedConstants[7] = constants[0]/(constants[1] <= constants[2]); + computedConstants[8] = constants[0] > constants[1]; + computedConstants[9] = constants[0]/(constants[1] > constants[2]); + computedConstants[10] = constants[0] >= constants[1]; + computedConstants[11] = constants[0]/(constants[1] >= constants[2]); + computedConstants[12] = constants[0] && constants[1]; + computedConstants[13] = constants[0] && constants[1] && constants[2]; + computedConstants[14] = (constants[0] < constants[1]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[0]+constants[1]) && (constants[2] > constants[3]); + computedConstants[16] = constants[0] && (constants[1] > constants[2]); + computedConstants[17] = (constants[0]-constants[1]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[0] && (constants[1] > constants[2]); + computedConstants[19] = pow(constants[0], constants[1]) && (constants[2] > constants[3]); + computedConstants[20] = pow(constants[0], 1.0/constants[1]) && (constants[2] > constants[3]); + computedConstants[21] = (constants[0] < constants[1]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[0] < constants[1]) && constants[2]; + computedConstants[23] = (constants[0] < constants[1]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[0] < constants[1]) && -constants[2]; + computedConstants[25] = (constants[0] < constants[1]) && pow(constants[2], constants[3]); + computedConstants[26] = (constants[0] < constants[1]) && pow(constants[2], 1.0/constants[3]); + computedConstants[27] = constants[0]/(constants[1] && constants[2]); + computedConstants[28] = constants[0] || constants[1]; + computedConstants[29] = constants[0] || constants[1] || constants[2]; + computedConstants[30] = (constants[0] < constants[1]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[0]+constants[1]) || (constants[2] > constants[3]); + computedConstants[32] = constants[0] || (constants[1] > constants[2]); + computedConstants[33] = (constants[0]-constants[1]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[0] || (constants[1] > constants[2]); + computedConstants[35] = pow(constants[0], constants[1]) || (constants[2] > constants[3]); + computedConstants[36] = pow(constants[0], 1.0/constants[1]) || (constants[2] > constants[3]); + computedConstants[37] = (constants[0] < constants[1]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[0] < constants[1]) || constants[2]; + computedConstants[39] = (constants[0] < constants[1]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[0] < constants[1]) || -constants[2]; + computedConstants[41] = (constants[0] < constants[1]) || pow(constants[2], constants[3]); + computedConstants[42] = (constants[0] < constants[1]) || pow(constants[2], 1.0/constants[3]); + computedConstants[43] = constants[0]/(constants[1] || constants[2]); + computedConstants[44] = xor(constants[0], constants[1]); + computedConstants[45] = xor(constants[0], xor(constants[1], constants[2])); + computedConstants[46] = xor(constants[0] < constants[1], constants[2] > constants[3]); + computedConstants[47] = xor(constants[0]+constants[1], constants[2] > constants[3]); + computedConstants[48] = xor(constants[0], constants[1] > constants[2]); + computedConstants[49] = xor(constants[0]-constants[1], constants[2] > constants[3]); + computedConstants[50] = xor(-constants[0], constants[1] > constants[2]); + computedConstants[51] = xor(pow(constants[0], constants[1]), constants[2] > constants[3]); + computedConstants[52] = xor(pow(constants[0], 1.0/constants[1]), constants[2] > constants[3]); + computedConstants[53] = xor(constants[0] < constants[1], constants[2]+constants[3]); + computedConstants[54] = xor(constants[0] < constants[1], constants[2]); + computedConstants[55] = xor(constants[0] < constants[1], constants[2]-constants[3]); + computedConstants[56] = xor(constants[0] < constants[1], -constants[2]); + computedConstants[57] = xor(constants[0] < constants[1], pow(constants[2], constants[3])); + computedConstants[58] = xor(constants[0] < constants[1], pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[0]/xor(constants[1], constants[2]); + computedConstants[60] = !constants[0]; + computedConstants[61] = constants[0]+constants[1]; + computedConstants[62] = constants[0]+constants[1]+constants[2]; + computedConstants[63] = (constants[0] < constants[1])+(constants[2] > constants[3]); + computedConstants[64] = constants[0]; + computedConstants[65] = constants[0]-constants[1]; + computedConstants[66] = (constants[0] < constants[1])-(constants[2] > constants[3]); + computedConstants[67] = (constants[0] < constants[1])-(constants[2]+constants[3]); + computedConstants[68] = (constants[0] < constants[1])-constants[2]; + computedConstants[69] = constants[0]-(-constants[1]); + computedConstants[70] = constants[0]-(-constants[1]*constants[2]); + computedConstants[71] = -constants[0]; + computedConstants[72] = -(constants[0] < constants[1]); + computedConstants[73] = constants[0]*constants[1]; + computedConstants[74] = constants[0]*constants[1]*constants[2]; + computedConstants[75] = (constants[0] < constants[1])*(constants[2] > constants[3]); + computedConstants[76] = (constants[0]+constants[1])*(constants[2] > constants[3]); + computedConstants[77] = constants[0]*(constants[1] > constants[2]); + computedConstants[78] = (constants[0]-constants[1])*(constants[2] > constants[3]); + computedConstants[79] = -constants[0]*(constants[1] > constants[2]); + computedConstants[80] = (constants[0] < constants[1])*(constants[2]+constants[3]); + computedConstants[81] = (constants[0] < constants[1])*constants[2]; + computedConstants[82] = (constants[0] < constants[1])*(constants[2]-constants[3]); + computedConstants[83] = (constants[0] < constants[1])*-constants[2]; + computedConstants[84] = constants[0]/constants[1]; + computedConstants[85] = (constants[0] < constants[1])/(constants[3] > constants[2]); + computedConstants[86] = (constants[0]+constants[1])/(constants[3] > constants[2]); + computedConstants[87] = constants[0]/(constants[2] > constants[1]); + computedConstants[88] = (constants[0]-constants[1])/(constants[3] > constants[2]); + computedConstants[89] = -constants[0]/(constants[2] > constants[1]); + computedConstants[90] = (constants[0] < constants[1])/(constants[2]+constants[3]); + computedConstants[91] = (constants[0] < constants[1])/constants[2]; + computedConstants[92] = (constants[0] < constants[1])/(constants[2]-constants[3]); + computedConstants[93] = (constants[0] < constants[1])/-constants[2]; + computedConstants[94] = (constants[0] < constants[1])/(constants[2]*constants[3]); + computedConstants[95] = (constants[0] < constants[1])/(constants[2]/constants[3]); + computedConstants[96] = sqrt(constants[0]); + computedConstants[97] = pow(constants[0], 2.0); + computedConstants[98] = pow(constants[0], 3.0); + computedConstants[99] = pow(constants[0], constants[1]); + computedConstants[100] = pow(constants[0] <= constants[1], constants[2] >= constants[3]); + computedConstants[101] = pow(constants[0]+constants[1], constants[2] >= constants[3]); + computedConstants[102] = pow(constants[0], constants[1] >= constants[2]); + computedConstants[103] = pow(constants[0]-constants[1], constants[2] >= constants[3]); + computedConstants[104] = pow(-constants[0], constants[1] >= constants[2]); + computedConstants[105] = pow(constants[0]*constants[1], constants[2] >= constants[3]); + computedConstants[106] = pow(constants[0]/constants[1], constants[2] >= constants[3]); + computedConstants[107] = pow(constants[0] <= constants[1], constants[2]+constants[3]); + computedConstants[108] = pow(constants[0] <= constants[1], constants[2]); + computedConstants[109] = pow(constants[0] <= constants[1], constants[2]-constants[3]); + computedConstants[110] = pow(constants[0] <= constants[1], -constants[2]); + computedConstants[111] = pow(constants[0] <= constants[1], constants[2]*constants[3]); + computedConstants[112] = pow(constants[0] <= constants[1], constants[2]/constants[3]); + computedConstants[113] = pow(constants[0] <= constants[1], pow(constants[2], constants[3])); + computedConstants[114] = pow(constants[0] <= constants[1], pow(constants[2], 1.0/constants[3])); + computedConstants[115] = sqrt(constants[0]); + computedConstants[116] = sqrt(constants[0]); + computedConstants[117] = pow(constants[0], 1.0/3.0); + computedConstants[118] = pow(constants[0], 1.0/constants[1]); + computedConstants[119] = pow(constants[0] < constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[120] = pow(constants[0]+constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[121] = pow(constants[0], 1.0/(constants[2] > constants[1])); + computedConstants[122] = pow(constants[0]-constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[123] = pow(-constants[0], 1.0/(constants[2] > constants[1])); + computedConstants[124] = pow(constants[0]*constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[125] = pow(constants[0]/constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[126] = pow(constants[0] < constants[1], 1.0/(constants[2]+constants[3])); + computedConstants[127] = pow(constants[0] < constants[1], 1.0/constants[2]); + computedConstants[128] = pow(constants[0] < constants[1], 1.0/(constants[2]-constants[3])); + computedConstants[129] = pow(constants[0] < constants[1], 1.0/-constants[2]); + computedConstants[130] = pow(constants[0] < constants[1], 1.0/(constants[2]*constants[3])); + computedConstants[131] = pow(constants[0] < constants[1], 1.0/(constants[2]/constants[3])); + computedConstants[132] = pow(constants[0] < constants[1], 1.0/pow(constants[2], constants[3])); + computedConstants[133] = pow(constants[0] < constants[1], 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[134] = fabs(constants[0]); + computedConstants[135] = exp(constants[0]); + computedConstants[136] = log(constants[0]); + computedConstants[137] = log10(constants[0]); + computedConstants[138] = log(constants[0])/log(2.0); + computedConstants[139] = log10(constants[0]); + computedConstants[140] = log(constants[0])/log(constants[1]); + computedConstants[141] = ceil(constants[0]); + computedConstants[142] = floor(constants[0]); + computedConstants[143] = min(constants[0], constants[1]); + computedConstants[144] = min(constants[0], min(constants[1], constants[2])); + computedConstants[145] = max(constants[0], constants[1]); + computedConstants[146] = max(constants[0], max(constants[1], constants[2])); + computedConstants[147] = fmod(constants[0], constants[1]); + computedConstants[148] = sin(constants[0]); + computedConstants[149] = cos(constants[0]); + computedConstants[150] = tan(constants[0]); + computedConstants[151] = sec(constants[0]); + computedConstants[152] = csc(constants[0]); + computedConstants[153] = cot(constants[0]); + computedConstants[154] = sinh(constants[0]); + computedConstants[155] = cosh(constants[0]); + computedConstants[156] = tanh(constants[0]); + computedConstants[157] = sech(constants[0]); + computedConstants[158] = csch(constants[0]); + computedConstants[159] = coth(constants[0]); + computedConstants[160] = asin(constants[0]); + computedConstants[161] = acos(constants[0]); + computedConstants[162] = atan(constants[0]); + computedConstants[163] = asec(constants[0]); + computedConstants[164] = acsc(constants[0]); + computedConstants[165] = acot(constants[0]); + computedConstants[166] = asinh(constants[0]); + computedConstants[167] = acosh(constants[0]); + computedConstants[168] = atanh(constants[0]/2.0); + computedConstants[169] = asech(constants[0]); + computedConstants[170] = acsch(constants[0]); + computedConstants[171] = acoth(2.0*constants[0]); + computedConstants[172] = (constants[0] > constants[1])?constants[0]:NAN; + computedConstants[173] = (constants[0] > constants[1])?constants[0]:constants[2]; + computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; + computedConstants[175] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; + computedConstants[176] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); + computedConstants[181] = constants[0]; + computedConstants[188] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[189] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); + computedConstants[190] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); + computedConstants[191] = (constants[0] && constants[1])/(((constants[2] > constants[3])?constants[1]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[1]:NAN))); + computedConstants[192] = (constants[0] || constants[1]) && xor(constants[0], constants[1]) && ((constants[2] > constants[3])?constants[1]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[1]:NAN) && xor(constants[0], constants[1]) && (constants[0] || constants[1]); + computedConstants[193] = (constants[0] && constants[1]) || xor(constants[0], constants[1]) || ((constants[2] > constants[3])?constants[1]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[1]:NAN) || xor(constants[0], constants[1]) || (constants[0] && constants[1]); + computedConstants[194] = xor(constants[0] && constants[1], xor(constants[0] || constants[1], xor((constants[2] > constants[3])?constants[1]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] || constants[1]), constants[0] && constants[1])))); + computedConstants[195] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); + computedConstants[196] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); + computedConstants[197] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 4eeb5c9fa..4f4499cf7 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -359,239 +359,239 @@ def objective_function_0(u, f, data): rates = data[2] variables = data[3] - algebraic[205] = u[0] - algebraic[206] = u[1] + algebraic[0] = u[0] + algebraic[1] = u[1] - f[0] = algebraic[205]+algebraic[206]+states[0]-0.0 - f[1] = algebraic[205]-algebraic[206]-(computed_constants[207]+computed_constants[208]) + f[0] = algebraic[0]+algebraic[1]+states[0]-0.0 + f[1] = algebraic[0]-algebraic[1]-(computed_constants[198]+computed_constants[199]) def find_root_0(voi, states, rates, variables): u = [nan]*2 - u[0] = algebraic[205] - u[1] = algebraic[206] + u[0] = algebraic[0] + u[1] = algebraic[1] u = nla_solve(objective_function_0, u, 2, [voi, states, rates, variables]) - algebraic[205] = u[0] - algebraic[206] = u[1] + algebraic[0] = u[0] + algebraic[1] = u[1] def initialise_variables(states, rates, constants): - constants[1] = 1.0 - constants[2] = 2.0 - constants[6] = 3.0 - constants[18] = 4.0 - constants[179] = 5.0 - constants[180] = 6.0 - constants[182] = 7.0 - algebraic[205] = 1.0 - algebraic[206] = 2.0 - computed_constants[184] = 123.0 - computed_constants[185] = 123.456789 - computed_constants[186] = 123.0e99 - computed_constants[187] = 123.456789e99 - computed_constants[189] = 1.0 - computed_constants[190] = 0.0 - computed_constants[191] = 2.71828182845905 - computed_constants[192] = 3.14159265358979 - computed_constants[193] = inf - computed_constants[194] = nan - computed_constants[207] = 1.0 - computed_constants[208] = 3.0 + constants[0] = 1.0 + constants[1] = 2.0 + constants[2] = 3.0 + constants[3] = 4.0 + constants[4] = 5.0 + constants[5] = 6.0 + constants[6] = 7.0 + algebraic[0] = 1.0 + algebraic[1] = 2.0 + computed_constants[177] = 123.0 + computed_constants[178] = 123.456789 + computed_constants[179] = 123.0e99 + computed_constants[180] = 123.456789e99 + computed_constants[182] = 1.0 + computed_constants[183] = 0.0 + computed_constants[184] = 2.71828182845905 + computed_constants[185] = 3.14159265358979 + computed_constants[186] = inf + computed_constants[187] = nan + computed_constants[198] = 1.0 + computed_constants[199] = 3.0 states[0] = 0.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = eq_func(constants[1], constants[2]) - computed_constants[3] = constants[1]/eq_func(constants[2], constants[2]) - computed_constants[4] = neq_func(constants[1], constants[2]) - computed_constants[5] = constants[1]/neq_func(constants[2], constants[6]) - computed_constants[7] = lt_func(constants[1], constants[2]) - computed_constants[8] = constants[1]/lt_func(constants[2], constants[6]) - computed_constants[9] = leq_func(constants[1], constants[2]) - computed_constants[10] = constants[1]/leq_func(constants[2], constants[6]) - computed_constants[11] = gt_func(constants[1], constants[2]) - computed_constants[12] = constants[1]/gt_func(constants[2], constants[6]) - computed_constants[13] = geq_func(constants[1], constants[2]) - computed_constants[14] = constants[1]/geq_func(constants[2], constants[6]) - computed_constants[15] = and_func(constants[1], constants[2]) - computed_constants[16] = and_func(constants[1], and_func(constants[2], constants[6])) - computed_constants[17] = and_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[19] = and_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) - computed_constants[20] = and_func(constants[1], gt_func(constants[2], constants[6])) - computed_constants[21] = and_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) - computed_constants[22] = and_func(-constants[1], gt_func(constants[2], constants[6])) - computed_constants[23] = and_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[24] = and_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) - computed_constants[25] = and_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) - computed_constants[26] = and_func(lt_func(constants[1], constants[2]), constants[6]) - computed_constants[27] = and_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) - computed_constants[28] = and_func(lt_func(constants[1], constants[2]), -constants[6]) - computed_constants[29] = and_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) - computed_constants[30] = and_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) - computed_constants[31] = constants[1]/and_func(constants[2], constants[6]) - computed_constants[32] = or_func(constants[1], constants[2]) - computed_constants[33] = or_func(constants[1], or_func(constants[2], constants[6])) - computed_constants[34] = or_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[35] = or_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) - computed_constants[36] = or_func(constants[1], gt_func(constants[2], constants[6])) - computed_constants[37] = or_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) - computed_constants[38] = or_func(-constants[1], gt_func(constants[2], constants[6])) - computed_constants[39] = or_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[40] = or_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) - computed_constants[41] = or_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) - computed_constants[42] = or_func(lt_func(constants[1], constants[2]), constants[6]) - computed_constants[43] = or_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) - computed_constants[44] = or_func(lt_func(constants[1], constants[2]), -constants[6]) - computed_constants[45] = or_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) - computed_constants[46] = or_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) - computed_constants[47] = constants[1]/or_func(constants[2], constants[6]) - computed_constants[48] = xor_func(constants[1], constants[2]) - computed_constants[49] = xor_func(constants[1], xor_func(constants[2], constants[6])) - computed_constants[50] = xor_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[51] = xor_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) - computed_constants[52] = xor_func(constants[1], gt_func(constants[2], constants[6])) - computed_constants[53] = xor_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) - computed_constants[54] = xor_func(-constants[1], gt_func(constants[2], constants[6])) - computed_constants[55] = xor_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[56] = xor_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) - computed_constants[57] = xor_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) - computed_constants[58] = xor_func(lt_func(constants[1], constants[2]), constants[6]) - computed_constants[59] = xor_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) - computed_constants[60] = xor_func(lt_func(constants[1], constants[2]), -constants[6]) - computed_constants[61] = xor_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) - computed_constants[62] = xor_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) - computed_constants[63] = constants[1]/xor_func(constants[2], constants[6]) - computed_constants[64] = not_func(constants[1]) - computed_constants[65] = constants[1]+constants[2] - computed_constants[66] = constants[1]+constants[2]+constants[6] - computed_constants[67] = lt_func(constants[1], constants[2])+gt_func(constants[6], constants[18]) - computed_constants[68] = constants[1] - computed_constants[69] = constants[1]-constants[2] - computed_constants[70] = lt_func(constants[1], constants[2])-gt_func(constants[6], constants[18]) - computed_constants[71] = lt_func(constants[1], constants[2])-(constants[6]+constants[18]) - computed_constants[72] = lt_func(constants[1], constants[2])-constants[6] - computed_constants[73] = constants[1]-(-constants[2]) - computed_constants[74] = constants[1]-(-constants[2]*constants[6]) - computed_constants[75] = -constants[1] - computed_constants[76] = -lt_func(constants[1], constants[2]) - computed_constants[77] = constants[1]*constants[2] - computed_constants[78] = constants[1]*constants[2]*constants[6] - computed_constants[79] = lt_func(constants[1], constants[2])*gt_func(constants[6], constants[18]) - computed_constants[80] = (constants[1]+constants[2])*gt_func(constants[6], constants[18]) - computed_constants[81] = constants[1]*gt_func(constants[2], constants[6]) - computed_constants[82] = (constants[1]-constants[2])*gt_func(constants[6], constants[18]) - computed_constants[83] = -constants[1]*gt_func(constants[2], constants[6]) - computed_constants[84] = lt_func(constants[1], constants[2])*(constants[6]+constants[18]) - computed_constants[85] = lt_func(constants[1], constants[2])*constants[6] - computed_constants[86] = lt_func(constants[1], constants[2])*(constants[6]-constants[18]) - computed_constants[87] = lt_func(constants[1], constants[2])*-constants[6] - computed_constants[88] = constants[1]/constants[2] - computed_constants[89] = lt_func(constants[1], constants[2])/gt_func(constants[18], constants[6]) - computed_constants[90] = (constants[1]+constants[2])/gt_func(constants[18], constants[6]) - computed_constants[91] = constants[1]/gt_func(constants[6], constants[2]) - computed_constants[92] = (constants[1]-constants[2])/gt_func(constants[18], constants[6]) - computed_constants[93] = -constants[1]/gt_func(constants[6], constants[2]) - computed_constants[94] = lt_func(constants[1], constants[2])/(constants[6]+constants[18]) - computed_constants[95] = lt_func(constants[1], constants[2])/constants[6] - computed_constants[96] = lt_func(constants[1], constants[2])/(constants[6]-constants[18]) - computed_constants[97] = lt_func(constants[1], constants[2])/-constants[6] - computed_constants[98] = lt_func(constants[1], constants[2])/(constants[6]*constants[18]) - computed_constants[99] = lt_func(constants[1], constants[2])/(constants[6]/constants[18]) - computed_constants[100] = sqrt(constants[1]) - computed_constants[101] = pow(constants[1], 2.0) - computed_constants[102] = pow(constants[1], 3.0) - computed_constants[103] = pow(constants[1], constants[2]) - computed_constants[104] = pow(leq_func(constants[1], constants[2]), geq_func(constants[6], constants[18])) - computed_constants[105] = pow(constants[1]+constants[2], geq_func(constants[6], constants[18])) - computed_constants[106] = pow(constants[1], geq_func(constants[2], constants[6])) - computed_constants[107] = pow(constants[1]-constants[2], geq_func(constants[6], constants[18])) - computed_constants[108] = pow(-constants[1], geq_func(constants[2], constants[6])) - computed_constants[109] = pow(constants[1]*constants[2], geq_func(constants[6], constants[18])) - computed_constants[110] = pow(constants[1]/constants[2], geq_func(constants[6], constants[18])) - computed_constants[111] = pow(leq_func(constants[1], constants[2]), constants[6]+constants[18]) - computed_constants[112] = pow(leq_func(constants[1], constants[2]), constants[6]) - computed_constants[113] = pow(leq_func(constants[1], constants[2]), constants[6]-constants[18]) - computed_constants[114] = pow(leq_func(constants[1], constants[2]), -constants[6]) - computed_constants[115] = pow(leq_func(constants[1], constants[2]), constants[6]*constants[18]) - computed_constants[116] = pow(leq_func(constants[1], constants[2]), constants[6]/constants[18]) - computed_constants[117] = pow(leq_func(constants[1], constants[2]), pow(constants[6], constants[18])) - computed_constants[118] = pow(leq_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) - computed_constants[119] = sqrt(constants[1]) - computed_constants[120] = sqrt(constants[1]) - computed_constants[121] = pow(constants[1], 1.0/3.0) - computed_constants[122] = pow(constants[1], 1.0/constants[2]) - computed_constants[123] = pow(lt_func(constants[1], constants[2]), 1.0/gt_func(constants[18], constants[6])) - computed_constants[124] = pow(constants[1]+constants[2], 1.0/gt_func(constants[18], constants[6])) - computed_constants[125] = pow(constants[1], 1.0/gt_func(constants[6], constants[2])) - computed_constants[126] = pow(constants[1]-constants[2], 1.0/gt_func(constants[18], constants[6])) - computed_constants[127] = pow(-constants[1], 1.0/gt_func(constants[6], constants[2])) - computed_constants[128] = pow(constants[1]*constants[2], 1.0/gt_func(constants[18], constants[6])) - computed_constants[129] = pow(constants[1]/constants[2], 1.0/gt_func(constants[18], constants[6])) - computed_constants[130] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]+constants[18])) - computed_constants[131] = pow(lt_func(constants[1], constants[2]), 1.0/constants[6]) - computed_constants[132] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]-constants[18])) - computed_constants[133] = pow(lt_func(constants[1], constants[2]), 1.0/-constants[6]) - computed_constants[134] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]*constants[18])) - computed_constants[135] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]/constants[18])) - computed_constants[136] = pow(lt_func(constants[1], constants[2]), 1.0/pow(constants[6], constants[18])) - computed_constants[137] = pow(lt_func(constants[1], constants[2]), 1.0/pow(constants[6], 1.0/constants[18])) - computed_constants[138] = fabs(constants[1]) - computed_constants[139] = exp(constants[1]) - computed_constants[140] = log(constants[1]) - computed_constants[141] = log10(constants[1]) - computed_constants[142] = log(constants[1])/log(2.0) - computed_constants[143] = log10(constants[1]) - computed_constants[144] = log(constants[1])/log(constants[2]) - computed_constants[145] = ceil(constants[1]) - computed_constants[146] = floor(constants[1]) - computed_constants[147] = min(constants[1], constants[2]) - computed_constants[148] = min(constants[1], min(constants[2], constants[6])) - computed_constants[149] = max(constants[1], constants[2]) - computed_constants[150] = max(constants[1], max(constants[2], constants[6])) - computed_constants[151] = fmod(constants[1], constants[2]) - computed_constants[152] = sin(constants[1]) - computed_constants[153] = cos(constants[1]) - computed_constants[154] = tan(constants[1]) - computed_constants[155] = sec(constants[1]) - computed_constants[156] = csc(constants[1]) - computed_constants[157] = cot(constants[1]) - computed_constants[158] = sinh(constants[1]) - computed_constants[159] = cosh(constants[1]) - computed_constants[160] = tanh(constants[1]) - computed_constants[161] = sech(constants[1]) - computed_constants[162] = csch(constants[1]) - computed_constants[163] = coth(constants[1]) - computed_constants[164] = asin(constants[1]) - computed_constants[165] = acos(constants[1]) - computed_constants[166] = atan(constants[1]) - computed_constants[167] = asec(constants[1]) - computed_constants[168] = acsc(constants[1]) - computed_constants[169] = acot(constants[1]) - computed_constants[170] = asinh(constants[1]) - computed_constants[171] = acosh(constants[1]) - computed_constants[172] = atanh(constants[1]/2.0) - computed_constants[173] = asech(constants[1]) - computed_constants[174] = acsch(constants[1]) - computed_constants[175] = acoth(2.0*constants[1]) - computed_constants[176] = constants[1] if gt_func(constants[1], constants[2]) else nan - computed_constants[177] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] - computed_constants[178] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] if gt_func(constants[6], constants[18]) else constants[179] if gt_func(constants[179], constants[180]) else nan - computed_constants[181] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] if gt_func(constants[6], constants[18]) else constants[179] if gt_func(constants[179], constants[180]) else constants[182] - computed_constants[183] = 123.0+(constants[1] if gt_func(constants[1], constants[2]) else nan) - computed_constants[188] = constants[1] - computed_constants[195] = and_func(constants[1], constants[2])+(constants[2] if gt_func(constants[6], constants[18]) else nan)+constants[179]+and_func(constants[180], constants[182]) - computed_constants[196] = and_func(constants[1], constants[2])-((constants[2] if gt_func(constants[6], constants[18]) else nan)-(constants[179]-(constants[2] if gt_func(constants[6], constants[18]) else nan)))-and_func(constants[180], constants[182]) - computed_constants[197] = and_func(constants[1], constants[2])*(constants[2] if gt_func(constants[6], constants[18]) else nan)*constants[179]*(constants[2] if gt_func(constants[6], constants[18]) else nan)*and_func(constants[180], constants[182]) - computed_constants[198] = and_func(constants[1], constants[2])/((constants[2] if gt_func(constants[6], constants[18]) else nan)/(constants[179]/(constants[2] if gt_func(constants[6], constants[18]) else nan))) - computed_constants[199] = and_func(or_func(constants[1], constants[2]), and_func(xor_func(constants[1], constants[2]), and_func(constants[2] if gt_func(constants[6], constants[18]) else nan, and_func(and_func(and_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), xor_func(constants[1], constants[2])), or_func(constants[1], constants[2]))))) - computed_constants[200] = or_func(and_func(constants[1], constants[2]), or_func(xor_func(constants[1], constants[2]), or_func(constants[2] if gt_func(constants[6], constants[18]) else nan, or_func(or_func(or_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), xor_func(constants[1], constants[2])), and_func(constants[1], constants[2]))))) - computed_constants[201] = xor_func(and_func(constants[1], constants[2]), xor_func(or_func(constants[1], constants[2]), xor_func(constants[2] if gt_func(constants[6], constants[18]) else nan, xor_func(xor_func(xor_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), or_func(constants[1], constants[2])), and_func(constants[1], constants[2]))))) - computed_constants[202] = pow(and_func(constants[1], constants[2]), pow(constants[2] if gt_func(constants[6], constants[18]) else nan, pow(pow(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), and_func(constants[1], constants[2])))) - computed_constants[203] = pow(pow(pow(and_func(constants[1], constants[2]), 1.0/pow(constants[2] if gt_func(constants[6], constants[18]) else nan, 1.0/constants[179])), 1.0/(constants[2] if gt_func(constants[6], constants[18]) else nan)), 1.0/and_func(constants[1], constants[2])) - computed_constants[204] = -and_func(constants[1], constants[2])+-(constants[2] if gt_func(constants[6], constants[18]) else nan) + computed_constants[0] = eq_func(constants[0], constants[1]) + computed_constants[1] = constants[0]/eq_func(constants[1], constants[1]) + computed_constants[2] = neq_func(constants[0], constants[1]) + computed_constants[3] = constants[0]/neq_func(constants[1], constants[2]) + computed_constants[4] = lt_func(constants[0], constants[1]) + computed_constants[5] = constants[0]/lt_func(constants[1], constants[2]) + computed_constants[6] = leq_func(constants[0], constants[1]) + computed_constants[7] = constants[0]/leq_func(constants[1], constants[2]) + computed_constants[8] = gt_func(constants[0], constants[1]) + computed_constants[9] = constants[0]/gt_func(constants[1], constants[2]) + computed_constants[10] = geq_func(constants[0], constants[1]) + computed_constants[11] = constants[0]/geq_func(constants[1], constants[2]) + computed_constants[12] = and_func(constants[0], constants[1]) + computed_constants[13] = and_func(constants[0], and_func(constants[1], constants[2])) + computed_constants[14] = and_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[15] = and_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) + computed_constants[16] = and_func(constants[0], gt_func(constants[1], constants[2])) + computed_constants[17] = and_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) + computed_constants[18] = and_func(-constants[0], gt_func(constants[1], constants[2])) + computed_constants[19] = and_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[20] = and_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) + computed_constants[21] = and_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) + computed_constants[22] = and_func(lt_func(constants[0], constants[1]), constants[2]) + computed_constants[23] = and_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) + computed_constants[24] = and_func(lt_func(constants[0], constants[1]), -constants[2]) + computed_constants[25] = and_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) + computed_constants[26] = and_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[27] = constants[0]/and_func(constants[1], constants[2]) + computed_constants[28] = or_func(constants[0], constants[1]) + computed_constants[29] = or_func(constants[0], or_func(constants[1], constants[2])) + computed_constants[30] = or_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[31] = or_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) + computed_constants[32] = or_func(constants[0], gt_func(constants[1], constants[2])) + computed_constants[33] = or_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) + computed_constants[34] = or_func(-constants[0], gt_func(constants[1], constants[2])) + computed_constants[35] = or_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[36] = or_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) + computed_constants[37] = or_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) + computed_constants[38] = or_func(lt_func(constants[0], constants[1]), constants[2]) + computed_constants[39] = or_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) + computed_constants[40] = or_func(lt_func(constants[0], constants[1]), -constants[2]) + computed_constants[41] = or_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) + computed_constants[42] = or_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[43] = constants[0]/or_func(constants[1], constants[2]) + computed_constants[44] = xor_func(constants[0], constants[1]) + computed_constants[45] = xor_func(constants[0], xor_func(constants[1], constants[2])) + computed_constants[46] = xor_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[47] = xor_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) + computed_constants[48] = xor_func(constants[0], gt_func(constants[1], constants[2])) + computed_constants[49] = xor_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) + computed_constants[50] = xor_func(-constants[0], gt_func(constants[1], constants[2])) + computed_constants[51] = xor_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[52] = xor_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) + computed_constants[53] = xor_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) + computed_constants[54] = xor_func(lt_func(constants[0], constants[1]), constants[2]) + computed_constants[55] = xor_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) + computed_constants[56] = xor_func(lt_func(constants[0], constants[1]), -constants[2]) + computed_constants[57] = xor_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) + computed_constants[58] = xor_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[59] = constants[0]/xor_func(constants[1], constants[2]) + computed_constants[60] = not_func(constants[0]) + computed_constants[61] = constants[0]+constants[1] + computed_constants[62] = constants[0]+constants[1]+constants[2] + computed_constants[63] = lt_func(constants[0], constants[1])+gt_func(constants[2], constants[3]) + computed_constants[64] = constants[0] + computed_constants[65] = constants[0]-constants[1] + computed_constants[66] = lt_func(constants[0], constants[1])-gt_func(constants[2], constants[3]) + computed_constants[67] = lt_func(constants[0], constants[1])-(constants[2]+constants[3]) + computed_constants[68] = lt_func(constants[0], constants[1])-constants[2] + computed_constants[69] = constants[0]-(-constants[1]) + computed_constants[70] = constants[0]-(-constants[1]*constants[2]) + computed_constants[71] = -constants[0] + computed_constants[72] = -lt_func(constants[0], constants[1]) + computed_constants[73] = constants[0]*constants[1] + computed_constants[74] = constants[0]*constants[1]*constants[2] + computed_constants[75] = lt_func(constants[0], constants[1])*gt_func(constants[2], constants[3]) + computed_constants[76] = (constants[0]+constants[1])*gt_func(constants[2], constants[3]) + computed_constants[77] = constants[0]*gt_func(constants[1], constants[2]) + computed_constants[78] = (constants[0]-constants[1])*gt_func(constants[2], constants[3]) + computed_constants[79] = -constants[0]*gt_func(constants[1], constants[2]) + computed_constants[80] = lt_func(constants[0], constants[1])*(constants[2]+constants[3]) + computed_constants[81] = lt_func(constants[0], constants[1])*constants[2] + computed_constants[82] = lt_func(constants[0], constants[1])*(constants[2]-constants[3]) + computed_constants[83] = lt_func(constants[0], constants[1])*-constants[2] + computed_constants[84] = constants[0]/constants[1] + computed_constants[85] = lt_func(constants[0], constants[1])/gt_func(constants[3], constants[2]) + computed_constants[86] = (constants[0]+constants[1])/gt_func(constants[3], constants[2]) + computed_constants[87] = constants[0]/gt_func(constants[2], constants[1]) + computed_constants[88] = (constants[0]-constants[1])/gt_func(constants[3], constants[2]) + computed_constants[89] = -constants[0]/gt_func(constants[2], constants[1]) + computed_constants[90] = lt_func(constants[0], constants[1])/(constants[2]+constants[3]) + computed_constants[91] = lt_func(constants[0], constants[1])/constants[2] + computed_constants[92] = lt_func(constants[0], constants[1])/(constants[2]-constants[3]) + computed_constants[93] = lt_func(constants[0], constants[1])/-constants[2] + computed_constants[94] = lt_func(constants[0], constants[1])/(constants[2]*constants[3]) + computed_constants[95] = lt_func(constants[0], constants[1])/(constants[2]/constants[3]) + computed_constants[96] = sqrt(constants[0]) + computed_constants[97] = pow(constants[0], 2.0) + computed_constants[98] = pow(constants[0], 3.0) + computed_constants[99] = pow(constants[0], constants[1]) + computed_constants[100] = pow(leq_func(constants[0], constants[1]), geq_func(constants[2], constants[3])) + computed_constants[101] = pow(constants[0]+constants[1], geq_func(constants[2], constants[3])) + computed_constants[102] = pow(constants[0], geq_func(constants[1], constants[2])) + computed_constants[103] = pow(constants[0]-constants[1], geq_func(constants[2], constants[3])) + computed_constants[104] = pow(-constants[0], geq_func(constants[1], constants[2])) + computed_constants[105] = pow(constants[0]*constants[1], geq_func(constants[2], constants[3])) + computed_constants[106] = pow(constants[0]/constants[1], geq_func(constants[2], constants[3])) + computed_constants[107] = pow(leq_func(constants[0], constants[1]), constants[2]+constants[3]) + computed_constants[108] = pow(leq_func(constants[0], constants[1]), constants[2]) + computed_constants[109] = pow(leq_func(constants[0], constants[1]), constants[2]-constants[3]) + computed_constants[110] = pow(leq_func(constants[0], constants[1]), -constants[2]) + computed_constants[111] = pow(leq_func(constants[0], constants[1]), constants[2]*constants[3]) + computed_constants[112] = pow(leq_func(constants[0], constants[1]), constants[2]/constants[3]) + computed_constants[113] = pow(leq_func(constants[0], constants[1]), pow(constants[2], constants[3])) + computed_constants[114] = pow(leq_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[115] = sqrt(constants[0]) + computed_constants[116] = sqrt(constants[0]) + computed_constants[117] = pow(constants[0], 1.0/3.0) + computed_constants[118] = pow(constants[0], 1.0/constants[1]) + computed_constants[119] = pow(lt_func(constants[0], constants[1]), 1.0/gt_func(constants[3], constants[2])) + computed_constants[120] = pow(constants[0]+constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[121] = pow(constants[0], 1.0/gt_func(constants[2], constants[1])) + computed_constants[122] = pow(constants[0]-constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[123] = pow(-constants[0], 1.0/gt_func(constants[2], constants[1])) + computed_constants[124] = pow(constants[0]*constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[125] = pow(constants[0]/constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[126] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]+constants[3])) + computed_constants[127] = pow(lt_func(constants[0], constants[1]), 1.0/constants[2]) + computed_constants[128] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]-constants[3])) + computed_constants[129] = pow(lt_func(constants[0], constants[1]), 1.0/-constants[2]) + computed_constants[130] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]*constants[3])) + computed_constants[131] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]/constants[3])) + computed_constants[132] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])) + computed_constants[133] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])) + computed_constants[134] = fabs(constants[0]) + computed_constants[135] = exp(constants[0]) + computed_constants[136] = log(constants[0]) + computed_constants[137] = log10(constants[0]) + computed_constants[138] = log(constants[0])/log(2.0) + computed_constants[139] = log10(constants[0]) + computed_constants[140] = log(constants[0])/log(constants[1]) + computed_constants[141] = ceil(constants[0]) + computed_constants[142] = floor(constants[0]) + computed_constants[143] = min(constants[0], constants[1]) + computed_constants[144] = min(constants[0], min(constants[1], constants[2])) + computed_constants[145] = max(constants[0], constants[1]) + computed_constants[146] = max(constants[0], max(constants[1], constants[2])) + computed_constants[147] = fmod(constants[0], constants[1]) + computed_constants[148] = sin(constants[0]) + computed_constants[149] = cos(constants[0]) + computed_constants[150] = tan(constants[0]) + computed_constants[151] = sec(constants[0]) + computed_constants[152] = csc(constants[0]) + computed_constants[153] = cot(constants[0]) + computed_constants[154] = sinh(constants[0]) + computed_constants[155] = cosh(constants[0]) + computed_constants[156] = tanh(constants[0]) + computed_constants[157] = sech(constants[0]) + computed_constants[158] = csch(constants[0]) + computed_constants[159] = coth(constants[0]) + computed_constants[160] = asin(constants[0]) + computed_constants[161] = acos(constants[0]) + computed_constants[162] = atan(constants[0]) + computed_constants[163] = asec(constants[0]) + computed_constants[164] = acsc(constants[0]) + computed_constants[165] = acot(constants[0]) + computed_constants[166] = asinh(constants[0]) + computed_constants[167] = acosh(constants[0]) + computed_constants[168] = atanh(constants[0]/2.0) + computed_constants[169] = asech(constants[0]) + computed_constants[170] = acsch(constants[0]) + computed_constants[171] = acoth(2.0*constants[0]) + computed_constants[172] = constants[0] if gt_func(constants[0], constants[1]) else nan + computed_constants[173] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] + computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan + computed_constants[175] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] + computed_constants[176] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) + computed_constants[181] = constants[0] + computed_constants[188] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) + computed_constants[189] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) + computed_constants[190] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) + computed_constants[191] = and_func(constants[0], constants[1])/((constants[1] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[1] if gt_func(constants[2], constants[3]) else nan))) + computed_constants[192] = and_func(or_func(constants[0], constants[1]), and_func(xor_func(constants[0], constants[1]), and_func(constants[1] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), or_func(constants[0], constants[1]))))) + computed_constants[193] = or_func(and_func(constants[0], constants[1]), or_func(xor_func(constants[0], constants[1]), or_func(constants[1] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) + computed_constants[194] = xor_func(and_func(constants[0], constants[1]), xor_func(or_func(constants[0], constants[1]), xor_func(constants[1] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), or_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) + computed_constants[195] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) + computed_constants[196] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) + computed_constants[197] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index f35ae1622..97c8f0037 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -95,11 +95,11 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[205] = u[0]; - algebraic[206] = u[1]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; - f[0] = algebraic[205]+algebraic[206]+states[0]-0.0; - f[1] = algebraic[205]-algebraic[206]-(computedConstants[207]+computedConstants[208]); + f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; + f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -107,231 +107,231 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[2]; - u[0] = algebraic[205]; - u[1] = algebraic[206]; + u[0] = algebraic[0]; + u[1] = algebraic[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[205] = u[0]; - algebraic[206] = u[1]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; } void initialiseVariables(double *states, double *rates, double *constants) { - constants[1] = 1.0; - constants[2] = 2.0; - constants[6] = 3.0; - constants[18] = 4.0; - constants[179] = 5.0; - constants[180] = 6.0; - constants[182] = 7.0; - algebraic[205] = 1.0; - algebraic[206] = 2.0; - computedConstants[184] = 123.0; - computedConstants[185] = 123.456789; - computedConstants[186] = 123.0e99; - computedConstants[187] = 123.456789e99; - computedConstants[189] = 1.0; - computedConstants[190] = 0.0; - computedConstants[191] = 2.71828182845905; - computedConstants[192] = 3.14159265358979; - computedConstants[193] = INFINITY; - computedConstants[194] = NAN; - computedConstants[207] = 1.0; - computedConstants[208] = 3.0; + constants[0] = 1.0; + constants[1] = 2.0; + constants[2] = 3.0; + constants[3] = 4.0; + constants[4] = 5.0; + constants[5] = 6.0; + constants[6] = 7.0; + algebraic[0] = 1.0; + algebraic[1] = 2.0; + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = constants[1] == constants[2]; - computedConstants[3] = constants[1]/(constants[2] == constants[2]); - computedConstants[4] = constants[1] != constants[2]; - computedConstants[5] = constants[1]/(constants[2] != constants[6]); - computedConstants[7] = constants[1] < constants[2]; - computedConstants[8] = constants[1]/(constants[2] < constants[6]); - computedConstants[9] = constants[1] <= constants[2]; - computedConstants[10] = constants[1]/(constants[2] <= constants[6]); - computedConstants[11] = constants[1] > constants[2]; - computedConstants[12] = constants[1]/(constants[2] > constants[6]); - computedConstants[13] = constants[1] >= constants[2]; - computedConstants[14] = constants[1]/(constants[2] >= constants[6]); - computedConstants[15] = constants[1] && constants[2]; - computedConstants[16] = constants[1] && constants[2] && constants[6]; - computedConstants[17] = (constants[1] < constants[2]) && (constants[6] > constants[18]); - computedConstants[19] = (constants[1]+constants[2]) && (constants[6] > constants[18]); - computedConstants[20] = constants[1] && (constants[2] > constants[6]); - computedConstants[21] = (constants[1]-constants[2]) && (constants[6] > constants[18]); - computedConstants[22] = -constants[1] && (constants[2] > constants[6]); - computedConstants[23] = (constants[1]^^constants[2]) && (constants[6] > constants[18]); - computedConstants[24] = (constants[1]^^(1.0/constants[2])) && (constants[6] > constants[18]); - computedConstants[25] = (constants[1] < constants[2]) && (constants[6]+constants[18]); - computedConstants[26] = (constants[1] < constants[2]) && constants[6]; - computedConstants[27] = (constants[1] < constants[2]) && (constants[6]-constants[18]); - computedConstants[28] = (constants[1] < constants[2]) && -constants[6]; - computedConstants[29] = (constants[1] < constants[2]) && (constants[6]^^constants[18]); - computedConstants[30] = (constants[1] < constants[2]) && (constants[6]^^(1.0/constants[18])); - computedConstants[31] = constants[1]/(constants[2] && constants[6]); - computedConstants[32] = constants[1] || constants[2]; - computedConstants[33] = constants[1] || constants[2] || constants[6]; - computedConstants[34] = (constants[1] < constants[2]) || (constants[6] > constants[18]); - computedConstants[35] = (constants[1]+constants[2]) || (constants[6] > constants[18]); - computedConstants[36] = constants[1] || (constants[2] > constants[6]); - computedConstants[37] = (constants[1]-constants[2]) || (constants[6] > constants[18]); - computedConstants[38] = -constants[1] || (constants[2] > constants[6]); - computedConstants[39] = (constants[1]^^constants[2]) || (constants[6] > constants[18]); - computedConstants[40] = (constants[1]^^(1.0/constants[2])) || (constants[6] > constants[18]); - computedConstants[41] = (constants[1] < constants[2]) || (constants[6]+constants[18]); - computedConstants[42] = (constants[1] < constants[2]) || constants[6]; - computedConstants[43] = (constants[1] < constants[2]) || (constants[6]-constants[18]); - computedConstants[44] = (constants[1] < constants[2]) || -constants[6]; - computedConstants[45] = (constants[1] < constants[2]) || (constants[6]^^constants[18]); - computedConstants[46] = (constants[1] < constants[2]) || (constants[6]^^(1.0/constants[18])); - computedConstants[47] = constants[1]/(constants[2] || constants[6]); - computedConstants[48] = constants[1]^constants[2]; - computedConstants[49] = constants[1]^constants[2]^constants[6]; - computedConstants[50] = (constants[1] < constants[2])^(constants[6] > constants[18]); - computedConstants[51] = (constants[1]+constants[2])^(constants[6] > constants[18]); - computedConstants[52] = constants[1]^(constants[2] > constants[6]); - computedConstants[53] = (constants[1]-constants[2])^(constants[6] > constants[18]); - computedConstants[54] = -constants[1]^(constants[2] > constants[6]); - computedConstants[55] = (constants[1]^^constants[2])^(constants[6] > constants[18]); - computedConstants[56] = (constants[1]^^(1.0/constants[2]))^(constants[6] > constants[18]); - computedConstants[57] = (constants[1] < constants[2])^(constants[6]+constants[18]); - computedConstants[58] = (constants[1] < constants[2])^constants[6]; - computedConstants[59] = (constants[1] < constants[2])^(constants[6]-constants[18]); - computedConstants[60] = (constants[1] < constants[2])^-constants[6]; - computedConstants[61] = (constants[1] < constants[2])^(constants[6]^^constants[18]); - computedConstants[62] = (constants[1] < constants[2])^(constants[6]^^(1.0/constants[18])); - computedConstants[63] = constants[1]/(constants[2]^constants[6]); - computedConstants[64] = !constants[1]; - computedConstants[65] = constants[1]+constants[2]; - computedConstants[66] = constants[1]+constants[2]+constants[6]; - computedConstants[67] = (constants[1] < constants[2])+(constants[6] > constants[18]); - computedConstants[68] = constants[1]; - computedConstants[69] = constants[1]-constants[2]; - computedConstants[70] = (constants[1] < constants[2])-(constants[6] > constants[18]); - computedConstants[71] = (constants[1] < constants[2])-(constants[6]+constants[18]); - computedConstants[72] = (constants[1] < constants[2])-constants[6]; - computedConstants[73] = constants[1]-(-constants[2]); - computedConstants[74] = constants[1]-(-constants[2]*constants[6]); - computedConstants[75] = -constants[1]; - computedConstants[76] = -(constants[1] < constants[2]); - computedConstants[77] = constants[1]*constants[2]; - computedConstants[78] = constants[1]*constants[2]*constants[6]; - computedConstants[79] = (constants[1] < constants[2])*(constants[6] > constants[18]); - computedConstants[80] = (constants[1]+constants[2])*(constants[6] > constants[18]); - computedConstants[81] = constants[1]*(constants[2] > constants[6]); - computedConstants[82] = (constants[1]-constants[2])*(constants[6] > constants[18]); - computedConstants[83] = -constants[1]*(constants[2] > constants[6]); - computedConstants[84] = (constants[1] < constants[2])*(constants[6]+constants[18]); - computedConstants[85] = (constants[1] < constants[2])*constants[6]; - computedConstants[86] = (constants[1] < constants[2])*(constants[6]-constants[18]); - computedConstants[87] = (constants[1] < constants[2])*-constants[6]; - computedConstants[88] = constants[1]/constants[2]; - computedConstants[89] = (constants[1] < constants[2])/(constants[18] > constants[6]); - computedConstants[90] = (constants[1]+constants[2])/(constants[18] > constants[6]); - computedConstants[91] = constants[1]/(constants[6] > constants[2]); - computedConstants[92] = (constants[1]-constants[2])/(constants[18] > constants[6]); - computedConstants[93] = -constants[1]/(constants[6] > constants[2]); - computedConstants[94] = (constants[1] < constants[2])/(constants[6]+constants[18]); - computedConstants[95] = (constants[1] < constants[2])/constants[6]; - computedConstants[96] = (constants[1] < constants[2])/(constants[6]-constants[18]); - computedConstants[97] = (constants[1] < constants[2])/-constants[6]; - computedConstants[98] = (constants[1] < constants[2])/(constants[6]*constants[18]); - computedConstants[99] = (constants[1] < constants[2])/(constants[6]/constants[18]); - computedConstants[100] = sqrt(constants[1]); - computedConstants[101] = sqr(constants[1]); - computedConstants[102] = constants[1]^^3.0; - computedConstants[103] = constants[1]^^constants[2]; - computedConstants[104] = (constants[1] <= constants[2])^^(constants[6] >= constants[18]); - computedConstants[105] = (constants[1]+constants[2])^^(constants[6] >= constants[18]); - computedConstants[106] = constants[1]^^(constants[2] >= constants[6]); - computedConstants[107] = (constants[1]-constants[2])^^(constants[6] >= constants[18]); - computedConstants[108] = (-constants[1])^^(constants[2] >= constants[6]); - computedConstants[109] = (constants[1]*constants[2])^^(constants[6] >= constants[18]); - computedConstants[110] = (constants[1]/constants[2])^^(constants[6] >= constants[18]); - computedConstants[111] = (constants[1] <= constants[2])^^(constants[6]+constants[18]); - computedConstants[112] = (constants[1] <= constants[2])^^constants[6]; - computedConstants[113] = (constants[1] <= constants[2])^^constants[6]-constants[18]; - computedConstants[114] = (constants[1] <= constants[2])^^-constants[6]; - computedConstants[115] = (constants[1] <= constants[2])^^(constants[6]*constants[18]); - computedConstants[116] = (constants[1] <= constants[2])^^(constants[6]/constants[18]); - computedConstants[117] = (constants[1] <= constants[2])^^(constants[6]^^constants[18]); - computedConstants[118] = (constants[1] <= constants[2])^^(constants[6]^^(1.0/constants[18])); - computedConstants[119] = sqrt(constants[1]); - computedConstants[120] = sqrt(constants[1]); - computedConstants[121] = constants[1]^^(1.0/3.0); - computedConstants[122] = constants[1]^^(1.0/constants[2]); - computedConstants[123] = (constants[1] < constants[2])^^(1.0/(constants[18] > constants[6])); - computedConstants[124] = (constants[1]+constants[2])^^(1.0/(constants[18] > constants[6])); - computedConstants[125] = constants[1]^^(1.0/(constants[6] > constants[2])); - computedConstants[126] = (constants[1]-constants[2])^^(1.0/(constants[18] > constants[6])); - computedConstants[127] = (-constants[1])^^(1.0/(constants[6] > constants[2])); - computedConstants[128] = (constants[1]*constants[2])^^(1.0/(constants[18] > constants[6])); - computedConstants[129] = (constants[1]/constants[2])^^(1.0/(constants[18] > constants[6])); - computedConstants[130] = (constants[1] < constants[2])^^(1.0/(constants[6]+constants[18])); - computedConstants[131] = (constants[1] < constants[2])^^(1.0/constants[6]); - computedConstants[132] = (constants[1] < constants[2])^^(1.0/(constants[6]-constants[18])); - computedConstants[133] = (constants[1] < constants[2])^^(1.0/(-constants[6])); - computedConstants[134] = (constants[1] < constants[2])^^(1.0/(constants[6]*constants[18])); - computedConstants[135] = (constants[1] < constants[2])^^(1.0/(constants[6]/constants[18])); - computedConstants[136] = (constants[1] < constants[2])^^(1.0/(constants[6]^^constants[18])); - computedConstants[137] = (constants[1] < constants[2])^^(1.0/(constants[6]^^(1.0/constants[18]))); - computedConstants[138] = fabs(constants[1]); - computedConstants[139] = exp(constants[1]); - computedConstants[140] = log(constants[1]); - computedConstants[141] = log10(constants[1]); - computedConstants[142] = log(constants[1])/log(2.0); - computedConstants[143] = log10(constants[1]); - computedConstants[144] = log(constants[1])/log(constants[2]); - computedConstants[145] = ceil(constants[1]); - computedConstants[146] = floor(constants[1]); - computedConstants[147] = min(constants[1], constants[2]); - computedConstants[148] = min(constants[1], min(constants[2], constants[6])); - computedConstants[149] = max(constants[1], constants[2]); - computedConstants[150] = max(constants[1], max(constants[2], constants[6])); - computedConstants[151] = fmod(constants[1], constants[2]); - computedConstants[152] = sin(constants[1]); - computedConstants[153] = cos(constants[1]); - computedConstants[154] = tan(constants[1]); - computedConstants[155] = sec(constants[1]); - computedConstants[156] = csc(constants[1]); - computedConstants[157] = cot(constants[1]); - computedConstants[158] = sinh(constants[1]); - computedConstants[159] = cosh(constants[1]); - computedConstants[160] = tanh(constants[1]); - computedConstants[161] = sech(constants[1]); - computedConstants[162] = csch(constants[1]); - computedConstants[163] = coth(constants[1]); - computedConstants[164] = asin(constants[1]); - computedConstants[165] = acos(constants[1]); - computedConstants[166] = atan(constants[1]); - computedConstants[167] = asec(constants[1]); - computedConstants[168] = acsc(constants[1]); - computedConstants[169] = acot(constants[1]); - computedConstants[170] = asinh(constants[1]); - computedConstants[171] = acosh(constants[1]); - computedConstants[172] = atanh(constants[1]/2.0); - computedConstants[173] = asech(constants[1]); - computedConstants[174] = acsch(constants[1]); - computedConstants[175] = acoth(2.0*constants[1]); - computedConstants[176] = piecewise(constants[1] > constants[2], constants[1], NAN); - computedConstants[177] = piecewise(constants[1] > constants[2], constants[1], constants[6]); - computedConstants[178] = piecewise(constants[1] > constants[2], constants[1], piecewise(constants[6] > constants[18], constants[6], piecewise(constants[179] > constants[180], constants[179], NAN))); - computedConstants[181] = piecewise(constants[1] > constants[2], constants[1], piecewise(constants[6] > constants[18], constants[6], piecewise(constants[179] > constants[180], constants[179], constants[182]))); - computedConstants[183] = 123.0+piecewise(constants[1] > constants[2], constants[1], NAN); - computedConstants[188] = constants[1]; - computedConstants[195] = (constants[1] && constants[2])+piecewise(constants[6] > constants[18], constants[2], NAN)+constants[179]+(constants[180] && constants[182]); - computedConstants[196] = (constants[1] && constants[2])-(piecewise(constants[6] > constants[18], constants[2], NAN)-(constants[179]-piecewise(constants[6] > constants[18], constants[2], NAN)))-(constants[180] && constants[182]); - computedConstants[197] = (constants[1] && constants[2])*piecewise(constants[6] > constants[18], constants[2], NAN)*constants[179]*piecewise(constants[6] > constants[18], constants[2], NAN)*(constants[180] && constants[182]); - computedConstants[198] = (constants[1] && constants[2])/(piecewise(constants[6] > constants[18], constants[2], NAN)/(constants[179]/piecewise(constants[6] > constants[18], constants[2], NAN))); - computedConstants[199] = (constants[1] || constants[2]) && (constants[1]^constants[2]) && piecewise(constants[6] > constants[18], constants[2], NAN) && constants[179] && piecewise(constants[6] > constants[18], constants[2], NAN) && (constants[1]^constants[2]) && (constants[1] || constants[2]); - computedConstants[200] = (constants[1] && constants[2]) || (constants[1]^constants[2]) || piecewise(constants[6] > constants[18], constants[2], NAN) || constants[179] || piecewise(constants[6] > constants[18], constants[2], NAN) || (constants[1]^constants[2]) || (constants[1] && constants[2]); - computedConstants[201] = (constants[1] && constants[2])^(constants[1] || constants[2])^piecewise(constants[6] > constants[18], constants[2], NAN)^constants[179]^piecewise(constants[6] > constants[18], constants[2], NAN)^(constants[1] || constants[2])^(constants[1] && constants[2]); - computedConstants[202] = (constants[1] && constants[2])^^(piecewise(constants[6] > constants[18], constants[2], NAN)^^(constants[179]^^piecewise(constants[6] > constants[18], constants[2], NAN)^^(constants[1] && constants[2]))); - computedConstants[203] = (constants[1] && constants[2])^^(1.0/(piecewise(constants[6] > constants[18], constants[2], NAN)^^(1.0/constants[179])))^^(1.0/piecewise(constants[6] > constants[18], constants[2], NAN))^^(1.0/(constants[1] && constants[2])); - computedConstants[204] = -(constants[1] && constants[2])+-piecewise(constants[6] > constants[18], constants[2], NAN); + computedConstants[0] = constants[0] == constants[1]; + computedConstants[1] = constants[0]/(constants[1] == constants[1]); + computedConstants[2] = constants[0] != constants[1]; + computedConstants[3] = constants[0]/(constants[1] != constants[2]); + computedConstants[4] = constants[0] < constants[1]; + computedConstants[5] = constants[0]/(constants[1] < constants[2]); + computedConstants[6] = constants[0] <= constants[1]; + computedConstants[7] = constants[0]/(constants[1] <= constants[2]); + computedConstants[8] = constants[0] > constants[1]; + computedConstants[9] = constants[0]/(constants[1] > constants[2]); + computedConstants[10] = constants[0] >= constants[1]; + computedConstants[11] = constants[0]/(constants[1] >= constants[2]); + computedConstants[12] = constants[0] && constants[1]; + computedConstants[13] = constants[0] && constants[1] && constants[2]; + computedConstants[14] = (constants[0] < constants[1]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[0]+constants[1]) && (constants[2] > constants[3]); + computedConstants[16] = constants[0] && (constants[1] > constants[2]); + computedConstants[17] = (constants[0]-constants[1]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[0] && (constants[1] > constants[2]); + computedConstants[19] = (constants[0]^^constants[1]) && (constants[2] > constants[3]); + computedConstants[20] = (constants[0]^^(1.0/constants[1])) && (constants[2] > constants[3]); + computedConstants[21] = (constants[0] < constants[1]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[0] < constants[1]) && constants[2]; + computedConstants[23] = (constants[0] < constants[1]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[0] < constants[1]) && -constants[2]; + computedConstants[25] = (constants[0] < constants[1]) && (constants[2]^^constants[3]); + computedConstants[26] = (constants[0] < constants[1]) && (constants[2]^^(1.0/constants[3])); + computedConstants[27] = constants[0]/(constants[1] && constants[2]); + computedConstants[28] = constants[0] || constants[1]; + computedConstants[29] = constants[0] || constants[1] || constants[2]; + computedConstants[30] = (constants[0] < constants[1]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[0]+constants[1]) || (constants[2] > constants[3]); + computedConstants[32] = constants[0] || (constants[1] > constants[2]); + computedConstants[33] = (constants[0]-constants[1]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[0] || (constants[1] > constants[2]); + computedConstants[35] = (constants[0]^^constants[1]) || (constants[2] > constants[3]); + computedConstants[36] = (constants[0]^^(1.0/constants[1])) || (constants[2] > constants[3]); + computedConstants[37] = (constants[0] < constants[1]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[0] < constants[1]) || constants[2]; + computedConstants[39] = (constants[0] < constants[1]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[0] < constants[1]) || -constants[2]; + computedConstants[41] = (constants[0] < constants[1]) || (constants[2]^^constants[3]); + computedConstants[42] = (constants[0] < constants[1]) || (constants[2]^^(1.0/constants[3])); + computedConstants[43] = constants[0]/(constants[1] || constants[2]); + computedConstants[44] = constants[0]^constants[1]; + computedConstants[45] = constants[0]^constants[1]^constants[2]; + computedConstants[46] = (constants[0] < constants[1])^(constants[2] > constants[3]); + computedConstants[47] = (constants[0]+constants[1])^(constants[2] > constants[3]); + computedConstants[48] = constants[0]^(constants[1] > constants[2]); + computedConstants[49] = (constants[0]-constants[1])^(constants[2] > constants[3]); + computedConstants[50] = -constants[0]^(constants[1] > constants[2]); + computedConstants[51] = (constants[0]^^constants[1])^(constants[2] > constants[3]); + computedConstants[52] = (constants[0]^^(1.0/constants[1]))^(constants[2] > constants[3]); + computedConstants[53] = (constants[0] < constants[1])^(constants[2]+constants[3]); + computedConstants[54] = (constants[0] < constants[1])^constants[2]; + computedConstants[55] = (constants[0] < constants[1])^(constants[2]-constants[3]); + computedConstants[56] = (constants[0] < constants[1])^-constants[2]; + computedConstants[57] = (constants[0] < constants[1])^(constants[2]^^constants[3]); + computedConstants[58] = (constants[0] < constants[1])^(constants[2]^^(1.0/constants[3])); + computedConstants[59] = constants[0]/(constants[1]^constants[2]); + computedConstants[60] = !constants[0]; + computedConstants[61] = constants[0]+constants[1]; + computedConstants[62] = constants[0]+constants[1]+constants[2]; + computedConstants[63] = (constants[0] < constants[1])+(constants[2] > constants[3]); + computedConstants[64] = constants[0]; + computedConstants[65] = constants[0]-constants[1]; + computedConstants[66] = (constants[0] < constants[1])-(constants[2] > constants[3]); + computedConstants[67] = (constants[0] < constants[1])-(constants[2]+constants[3]); + computedConstants[68] = (constants[0] < constants[1])-constants[2]; + computedConstants[69] = constants[0]-(-constants[1]); + computedConstants[70] = constants[0]-(-constants[1]*constants[2]); + computedConstants[71] = -constants[0]; + computedConstants[72] = -(constants[0] < constants[1]); + computedConstants[73] = constants[0]*constants[1]; + computedConstants[74] = constants[0]*constants[1]*constants[2]; + computedConstants[75] = (constants[0] < constants[1])*(constants[2] > constants[3]); + computedConstants[76] = (constants[0]+constants[1])*(constants[2] > constants[3]); + computedConstants[77] = constants[0]*(constants[1] > constants[2]); + computedConstants[78] = (constants[0]-constants[1])*(constants[2] > constants[3]); + computedConstants[79] = -constants[0]*(constants[1] > constants[2]); + computedConstants[80] = (constants[0] < constants[1])*(constants[2]+constants[3]); + computedConstants[81] = (constants[0] < constants[1])*constants[2]; + computedConstants[82] = (constants[0] < constants[1])*(constants[2]-constants[3]); + computedConstants[83] = (constants[0] < constants[1])*-constants[2]; + computedConstants[84] = constants[0]/constants[1]; + computedConstants[85] = (constants[0] < constants[1])/(constants[3] > constants[2]); + computedConstants[86] = (constants[0]+constants[1])/(constants[3] > constants[2]); + computedConstants[87] = constants[0]/(constants[2] > constants[1]); + computedConstants[88] = (constants[0]-constants[1])/(constants[3] > constants[2]); + computedConstants[89] = -constants[0]/(constants[2] > constants[1]); + computedConstants[90] = (constants[0] < constants[1])/(constants[2]+constants[3]); + computedConstants[91] = (constants[0] < constants[1])/constants[2]; + computedConstants[92] = (constants[0] < constants[1])/(constants[2]-constants[3]); + computedConstants[93] = (constants[0] < constants[1])/-constants[2]; + computedConstants[94] = (constants[0] < constants[1])/(constants[2]*constants[3]); + computedConstants[95] = (constants[0] < constants[1])/(constants[2]/constants[3]); + computedConstants[96] = sqrt(constants[0]); + computedConstants[97] = sqr(constants[0]); + computedConstants[98] = constants[0]^^3.0; + computedConstants[99] = constants[0]^^constants[1]; + computedConstants[100] = (constants[0] <= constants[1])^^(constants[2] >= constants[3]); + computedConstants[101] = (constants[0]+constants[1])^^(constants[2] >= constants[3]); + computedConstants[102] = constants[0]^^(constants[1] >= constants[2]); + computedConstants[103] = (constants[0]-constants[1])^^(constants[2] >= constants[3]); + computedConstants[104] = (-constants[0])^^(constants[1] >= constants[2]); + computedConstants[105] = (constants[0]*constants[1])^^(constants[2] >= constants[3]); + computedConstants[106] = (constants[0]/constants[1])^^(constants[2] >= constants[3]); + computedConstants[107] = (constants[0] <= constants[1])^^(constants[2]+constants[3]); + computedConstants[108] = (constants[0] <= constants[1])^^constants[2]; + computedConstants[109] = (constants[0] <= constants[1])^^constants[2]-constants[3]; + computedConstants[110] = (constants[0] <= constants[1])^^-constants[2]; + computedConstants[111] = (constants[0] <= constants[1])^^(constants[2]*constants[3]); + computedConstants[112] = (constants[0] <= constants[1])^^(constants[2]/constants[3]); + computedConstants[113] = (constants[0] <= constants[1])^^(constants[2]^^constants[3]); + computedConstants[114] = (constants[0] <= constants[1])^^(constants[2]^^(1.0/constants[3])); + computedConstants[115] = sqrt(constants[0]); + computedConstants[116] = sqrt(constants[0]); + computedConstants[117] = constants[0]^^(1.0/3.0); + computedConstants[118] = constants[0]^^(1.0/constants[1]); + computedConstants[119] = (constants[0] < constants[1])^^(1.0/(constants[3] > constants[2])); + computedConstants[120] = (constants[0]+constants[1])^^(1.0/(constants[3] > constants[2])); + computedConstants[121] = constants[0]^^(1.0/(constants[2] > constants[1])); + computedConstants[122] = (constants[0]-constants[1])^^(1.0/(constants[3] > constants[2])); + computedConstants[123] = (-constants[0])^^(1.0/(constants[2] > constants[1])); + computedConstants[124] = (constants[0]*constants[1])^^(1.0/(constants[3] > constants[2])); + computedConstants[125] = (constants[0]/constants[1])^^(1.0/(constants[3] > constants[2])); + computedConstants[126] = (constants[0] < constants[1])^^(1.0/(constants[2]+constants[3])); + computedConstants[127] = (constants[0] < constants[1])^^(1.0/constants[2]); + computedConstants[128] = (constants[0] < constants[1])^^(1.0/(constants[2]-constants[3])); + computedConstants[129] = (constants[0] < constants[1])^^(1.0/(-constants[2])); + computedConstants[130] = (constants[0] < constants[1])^^(1.0/(constants[2]*constants[3])); + computedConstants[131] = (constants[0] < constants[1])^^(1.0/(constants[2]/constants[3])); + computedConstants[132] = (constants[0] < constants[1])^^(1.0/(constants[2]^^constants[3])); + computedConstants[133] = (constants[0] < constants[1])^^(1.0/(constants[2]^^(1.0/constants[3]))); + computedConstants[134] = fabs(constants[0]); + computedConstants[135] = exp(constants[0]); + computedConstants[136] = log(constants[0]); + computedConstants[137] = log10(constants[0]); + computedConstants[138] = log(constants[0])/log(2.0); + computedConstants[139] = log10(constants[0]); + computedConstants[140] = log(constants[0])/log(constants[1]); + computedConstants[141] = ceil(constants[0]); + computedConstants[142] = floor(constants[0]); + computedConstants[143] = min(constants[0], constants[1]); + computedConstants[144] = min(constants[0], min(constants[1], constants[2])); + computedConstants[145] = max(constants[0], constants[1]); + computedConstants[146] = max(constants[0], max(constants[1], constants[2])); + computedConstants[147] = fmod(constants[0], constants[1]); + computedConstants[148] = sin(constants[0]); + computedConstants[149] = cos(constants[0]); + computedConstants[150] = tan(constants[0]); + computedConstants[151] = sec(constants[0]); + computedConstants[152] = csc(constants[0]); + computedConstants[153] = cot(constants[0]); + computedConstants[154] = sinh(constants[0]); + computedConstants[155] = cosh(constants[0]); + computedConstants[156] = tanh(constants[0]); + computedConstants[157] = sech(constants[0]); + computedConstants[158] = csch(constants[0]); + computedConstants[159] = coth(constants[0]); + computedConstants[160] = asin(constants[0]); + computedConstants[161] = acos(constants[0]); + computedConstants[162] = atan(constants[0]); + computedConstants[163] = asec(constants[0]); + computedConstants[164] = acsc(constants[0]); + computedConstants[165] = acot(constants[0]); + computedConstants[166] = asinh(constants[0]); + computedConstants[167] = acosh(constants[0]); + computedConstants[168] = atanh(constants[0]/2.0); + computedConstants[169] = asech(constants[0]); + computedConstants[170] = acsch(constants[0]); + computedConstants[171] = acoth(2.0*constants[0]); + computedConstants[172] = piecewise(constants[0] > constants[1], constants[0], NAN); + computedConstants[173] = piecewise(constants[0] > constants[1], constants[0], constants[2]); + computedConstants[174] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], NAN))); + computedConstants[175] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], constants[6]))); + computedConstants[176] = 123.0+piecewise(constants[0] > constants[1], constants[0], NAN); + computedConstants[181] = constants[0]; + computedConstants[188] = (constants[0] && constants[1])+piecewise(constants[2] > constants[3], constants[1], NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[189] = (constants[0] && constants[1])-(piecewise(constants[2] > constants[3], constants[1], NAN)-(constants[4]-piecewise(constants[2] > constants[3], constants[1], NAN)))-(constants[5] && constants[6]); + computedConstants[190] = (constants[0] && constants[1])*piecewise(constants[2] > constants[3], constants[1], NAN)*constants[4]*piecewise(constants[2] > constants[3], constants[1], NAN)*(constants[5] && constants[6]); + computedConstants[191] = (constants[0] && constants[1])/(piecewise(constants[2] > constants[3], constants[1], NAN)/(constants[4]/piecewise(constants[2] > constants[3], constants[1], NAN))); + computedConstants[192] = (constants[0] || constants[1]) && (constants[0]^constants[1]) && piecewise(constants[2] > constants[3], constants[1], NAN) && constants[4] && piecewise(constants[2] > constants[3], constants[1], NAN) && (constants[0]^constants[1]) && (constants[0] || constants[1]); + computedConstants[193] = (constants[0] && constants[1]) || (constants[0]^constants[1]) || piecewise(constants[2] > constants[3], constants[1], NAN) || constants[4] || piecewise(constants[2] > constants[3], constants[1], NAN) || (constants[0]^constants[1]) || (constants[0] && constants[1]); + computedConstants[194] = (constants[0] && constants[1])^(constants[0] || constants[1])^piecewise(constants[2] > constants[3], constants[1], NAN)^constants[4]^piecewise(constants[2] > constants[3], constants[1], NAN)^(constants[0] || constants[1])^(constants[0] && constants[1]); + computedConstants[195] = (constants[0] && constants[1])^^(piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[4]^^piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[0] && constants[1]))); + computedConstants[196] = (constants[0] && constants[1])^^(1.0/(piecewise(constants[2] > constants[3], constants[1], NAN)^^(1.0/constants[4])))^^(1.0/piecewise(constants[2] > constants[3], constants[1], NAN))^^(1.0/(constants[0] && constants[1])); + computedConstants[197] = -(constants[0] && constants[1])+-piecewise(constants[2] > constants[3], constants[1], NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index acbe541a5..b945c4eb0 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -359,239 +359,239 @@ def objective_function_0(u, f, data): rates = data[2] variables = data[3] - algebraic[205] = u[0] - algebraic[206] = u[1] + algebraic[0] = u[0] + algebraic[1] = u[1] - f[0] = algebraic[205]+algebraic[206]+states[0]-0.0 - f[1] = algebraic[205]-algebraic[206]-(computed_constants[207]+computed_constants[208]) + f[0] = algebraic[0]+algebraic[1]+states[0]-0.0 + f[1] = algebraic[0]-algebraic[1]-(computed_constants[198]+computed_constants[199]) def find_root_0(voi, states, rates, variables): u = [nan]*2 - u[0] = algebraic[205] - u[1] = algebraic[206] + u[0] = algebraic[0] + u[1] = algebraic[1] u = nla_solve(objective_function_0, u, 2, [voi, states, rates, variables]) - algebraic[205] = u[0] - algebraic[206] = u[1] + algebraic[0] = u[0] + algebraic[1] = u[1] def initialise_variables(states, rates, constants): - constants[1] = 1.0 - constants[2] = 2.0 - constants[6] = 3.0 - constants[18] = 4.0 - constants[179] = 5.0 - constants[180] = 6.0 - constants[182] = 7.0 - algebraic[205] = 1.0 - algebraic[206] = 2.0 - computed_constants[184] = 123.0 - computed_constants[185] = 123.456789 - computed_constants[186] = 123.0e99 - computed_constants[187] = 123.456789e99 - computed_constants[189] = 1.0 - computed_constants[190] = 0.0 - computed_constants[191] = 2.71828182845905 - computed_constants[192] = 3.14159265358979 - computed_constants[193] = inf - computed_constants[194] = nan - computed_constants[207] = 1.0 - computed_constants[208] = 3.0 + constants[0] = 1.0 + constants[1] = 2.0 + constants[2] = 3.0 + constants[3] = 4.0 + constants[4] = 5.0 + constants[5] = 6.0 + constants[6] = 7.0 + algebraic[0] = 1.0 + algebraic[1] = 2.0 + computed_constants[177] = 123.0 + computed_constants[178] = 123.456789 + computed_constants[179] = 123.0e99 + computed_constants[180] = 123.456789e99 + computed_constants[182] = 1.0 + computed_constants[183] = 0.0 + computed_constants[184] = 2.71828182845905 + computed_constants[185] = 3.14159265358979 + computed_constants[186] = inf + computed_constants[187] = nan + computed_constants[198] = 1.0 + computed_constants[199] = 3.0 states[0] = 0.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = eq_func(constants[1], constants[2]) - computed_constants[3] = constants[1]/eq_func(constants[2], constants[2]) - computed_constants[4] = neq_func(constants[1], constants[2]) - computed_constants[5] = constants[1]/neq_func(constants[2], constants[6]) - computed_constants[7] = lt_func(constants[1], constants[2]) - computed_constants[8] = constants[1]/lt_func(constants[2], constants[6]) - computed_constants[9] = leq_func(constants[1], constants[2]) - computed_constants[10] = constants[1]/leq_func(constants[2], constants[6]) - computed_constants[11] = gt_func(constants[1], constants[2]) - computed_constants[12] = constants[1]/gt_func(constants[2], constants[6]) - computed_constants[13] = geq_func(constants[1], constants[2]) - computed_constants[14] = constants[1]/geq_func(constants[2], constants[6]) - computed_constants[15] = and_func(constants[1], constants[2]) - computed_constants[16] = and_func(constants[1], and_func(constants[2], constants[6])) - computed_constants[17] = and_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[19] = and_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) - computed_constants[20] = and_func(constants[1], gt_func(constants[2], constants[6])) - computed_constants[21] = and_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) - computed_constants[22] = and_func(-constants[1], gt_func(constants[2], constants[6])) - computed_constants[23] = and_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[24] = and_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) - computed_constants[25] = and_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) - computed_constants[26] = and_func(lt_func(constants[1], constants[2]), constants[6]) - computed_constants[27] = and_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) - computed_constants[28] = and_func(lt_func(constants[1], constants[2]), -constants[6]) - computed_constants[29] = and_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) - computed_constants[30] = and_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) - computed_constants[31] = constants[1]/and_func(constants[2], constants[6]) - computed_constants[32] = or_func(constants[1], constants[2]) - computed_constants[33] = or_func(constants[1], or_func(constants[2], constants[6])) - computed_constants[34] = or_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[35] = or_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) - computed_constants[36] = or_func(constants[1], gt_func(constants[2], constants[6])) - computed_constants[37] = or_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) - computed_constants[38] = or_func(-constants[1], gt_func(constants[2], constants[6])) - computed_constants[39] = or_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[40] = or_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) - computed_constants[41] = or_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) - computed_constants[42] = or_func(lt_func(constants[1], constants[2]), constants[6]) - computed_constants[43] = or_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) - computed_constants[44] = or_func(lt_func(constants[1], constants[2]), -constants[6]) - computed_constants[45] = or_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) - computed_constants[46] = or_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) - computed_constants[47] = constants[1]/or_func(constants[2], constants[6]) - computed_constants[48] = xor_func(constants[1], constants[2]) - computed_constants[49] = xor_func(constants[1], xor_func(constants[2], constants[6])) - computed_constants[50] = xor_func(lt_func(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[51] = xor_func(constants[1]+constants[2], gt_func(constants[6], constants[18])) - computed_constants[52] = xor_func(constants[1], gt_func(constants[2], constants[6])) - computed_constants[53] = xor_func(constants[1]-constants[2], gt_func(constants[6], constants[18])) - computed_constants[54] = xor_func(-constants[1], gt_func(constants[2], constants[6])) - computed_constants[55] = xor_func(pow(constants[1], constants[2]), gt_func(constants[6], constants[18])) - computed_constants[56] = xor_func(pow(constants[1], 1.0/constants[2]), gt_func(constants[6], constants[18])) - computed_constants[57] = xor_func(lt_func(constants[1], constants[2]), constants[6]+constants[18]) - computed_constants[58] = xor_func(lt_func(constants[1], constants[2]), constants[6]) - computed_constants[59] = xor_func(lt_func(constants[1], constants[2]), constants[6]-constants[18]) - computed_constants[60] = xor_func(lt_func(constants[1], constants[2]), -constants[6]) - computed_constants[61] = xor_func(lt_func(constants[1], constants[2]), pow(constants[6], constants[18])) - computed_constants[62] = xor_func(lt_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) - computed_constants[63] = constants[1]/xor_func(constants[2], constants[6]) - computed_constants[64] = not_func(constants[1]) - computed_constants[65] = constants[1]+constants[2] - computed_constants[66] = constants[1]+constants[2]+constants[6] - computed_constants[67] = lt_func(constants[1], constants[2])+gt_func(constants[6], constants[18]) - computed_constants[68] = constants[1] - computed_constants[69] = constants[1]-constants[2] - computed_constants[70] = lt_func(constants[1], constants[2])-gt_func(constants[6], constants[18]) - computed_constants[71] = lt_func(constants[1], constants[2])-(constants[6]+constants[18]) - computed_constants[72] = lt_func(constants[1], constants[2])-constants[6] - computed_constants[73] = constants[1]-(-constants[2]) - computed_constants[74] = constants[1]-(-constants[2]*constants[6]) - computed_constants[75] = -constants[1] - computed_constants[76] = -lt_func(constants[1], constants[2]) - computed_constants[77] = constants[1]*constants[2] - computed_constants[78] = constants[1]*constants[2]*constants[6] - computed_constants[79] = lt_func(constants[1], constants[2])*gt_func(constants[6], constants[18]) - computed_constants[80] = (constants[1]+constants[2])*gt_func(constants[6], constants[18]) - computed_constants[81] = constants[1]*gt_func(constants[2], constants[6]) - computed_constants[82] = (constants[1]-constants[2])*gt_func(constants[6], constants[18]) - computed_constants[83] = -constants[1]*gt_func(constants[2], constants[6]) - computed_constants[84] = lt_func(constants[1], constants[2])*(constants[6]+constants[18]) - computed_constants[85] = lt_func(constants[1], constants[2])*constants[6] - computed_constants[86] = lt_func(constants[1], constants[2])*(constants[6]-constants[18]) - computed_constants[87] = lt_func(constants[1], constants[2])*-constants[6] - computed_constants[88] = constants[1]/constants[2] - computed_constants[89] = lt_func(constants[1], constants[2])/gt_func(constants[18], constants[6]) - computed_constants[90] = (constants[1]+constants[2])/gt_func(constants[18], constants[6]) - computed_constants[91] = constants[1]/gt_func(constants[6], constants[2]) - computed_constants[92] = (constants[1]-constants[2])/gt_func(constants[18], constants[6]) - computed_constants[93] = -constants[1]/gt_func(constants[6], constants[2]) - computed_constants[94] = lt_func(constants[1], constants[2])/(constants[6]+constants[18]) - computed_constants[95] = lt_func(constants[1], constants[2])/constants[6] - computed_constants[96] = lt_func(constants[1], constants[2])/(constants[6]-constants[18]) - computed_constants[97] = lt_func(constants[1], constants[2])/-constants[6] - computed_constants[98] = lt_func(constants[1], constants[2])/(constants[6]*constants[18]) - computed_constants[99] = lt_func(constants[1], constants[2])/(constants[6]/constants[18]) - computed_constants[100] = sqrt(constants[1]) - computed_constants[101] = pow(constants[1], 2.0) - computed_constants[102] = pow(constants[1], 3.0) - computed_constants[103] = pow(constants[1], constants[2]) - computed_constants[104] = pow(leq_func(constants[1], constants[2]), geq_func(constants[6], constants[18])) - computed_constants[105] = pow(constants[1]+constants[2], geq_func(constants[6], constants[18])) - computed_constants[106] = pow(constants[1], geq_func(constants[2], constants[6])) - computed_constants[107] = pow(constants[1]-constants[2], geq_func(constants[6], constants[18])) - computed_constants[108] = pow(-constants[1], geq_func(constants[2], constants[6])) - computed_constants[109] = pow(constants[1]*constants[2], geq_func(constants[6], constants[18])) - computed_constants[110] = pow(constants[1]/constants[2], geq_func(constants[6], constants[18])) - computed_constants[111] = pow(leq_func(constants[1], constants[2]), constants[6]+constants[18]) - computed_constants[112] = pow(leq_func(constants[1], constants[2]), constants[6]) - computed_constants[113] = pow(leq_func(constants[1], constants[2]), constants[6]-constants[18]) - computed_constants[114] = pow(leq_func(constants[1], constants[2]), -constants[6]) - computed_constants[115] = pow(leq_func(constants[1], constants[2]), constants[6]*constants[18]) - computed_constants[116] = pow(leq_func(constants[1], constants[2]), constants[6]/constants[18]) - computed_constants[117] = pow(leq_func(constants[1], constants[2]), pow(constants[6], constants[18])) - computed_constants[118] = pow(leq_func(constants[1], constants[2]), pow(constants[6], 1.0/constants[18])) - computed_constants[119] = sqrt(constants[1]) - computed_constants[120] = sqrt(constants[1]) - computed_constants[121] = pow(constants[1], 1.0/3.0) - computed_constants[122] = pow(constants[1], 1.0/constants[2]) - computed_constants[123] = pow(lt_func(constants[1], constants[2]), 1.0/gt_func(constants[18], constants[6])) - computed_constants[124] = pow(constants[1]+constants[2], 1.0/gt_func(constants[18], constants[6])) - computed_constants[125] = pow(constants[1], 1.0/gt_func(constants[6], constants[2])) - computed_constants[126] = pow(constants[1]-constants[2], 1.0/gt_func(constants[18], constants[6])) - computed_constants[127] = pow(-constants[1], 1.0/gt_func(constants[6], constants[2])) - computed_constants[128] = pow(constants[1]*constants[2], 1.0/gt_func(constants[18], constants[6])) - computed_constants[129] = pow(constants[1]/constants[2], 1.0/gt_func(constants[18], constants[6])) - computed_constants[130] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]+constants[18])) - computed_constants[131] = pow(lt_func(constants[1], constants[2]), 1.0/constants[6]) - computed_constants[132] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]-constants[18])) - computed_constants[133] = pow(lt_func(constants[1], constants[2]), 1.0/-constants[6]) - computed_constants[134] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]*constants[18])) - computed_constants[135] = pow(lt_func(constants[1], constants[2]), 1.0/(constants[6]/constants[18])) - computed_constants[136] = pow(lt_func(constants[1], constants[2]), 1.0/pow(constants[6], constants[18])) - computed_constants[137] = pow(lt_func(constants[1], constants[2]), 1.0/pow(constants[6], 1.0/constants[18])) - computed_constants[138] = fabs(constants[1]) - computed_constants[139] = exp(constants[1]) - computed_constants[140] = log(constants[1]) - computed_constants[141] = log10(constants[1]) - computed_constants[142] = log(constants[1])/log(2.0) - computed_constants[143] = log10(constants[1]) - computed_constants[144] = log(constants[1])/log(constants[2]) - computed_constants[145] = ceil(constants[1]) - computed_constants[146] = floor(constants[1]) - computed_constants[147] = min(constants[1], constants[2]) - computed_constants[148] = min(constants[1], min(constants[2], constants[6])) - computed_constants[149] = max(constants[1], constants[2]) - computed_constants[150] = max(constants[1], max(constants[2], constants[6])) - computed_constants[151] = fmod(constants[1], constants[2]) - computed_constants[152] = sin(constants[1]) - computed_constants[153] = cos(constants[1]) - computed_constants[154] = tan(constants[1]) - computed_constants[155] = sec(constants[1]) - computed_constants[156] = csc(constants[1]) - computed_constants[157] = cot(constants[1]) - computed_constants[158] = sinh(constants[1]) - computed_constants[159] = cosh(constants[1]) - computed_constants[160] = tanh(constants[1]) - computed_constants[161] = sech(constants[1]) - computed_constants[162] = csch(constants[1]) - computed_constants[163] = coth(constants[1]) - computed_constants[164] = asin(constants[1]) - computed_constants[165] = acos(constants[1]) - computed_constants[166] = atan(constants[1]) - computed_constants[167] = asec(constants[1]) - computed_constants[168] = acsc(constants[1]) - computed_constants[169] = acot(constants[1]) - computed_constants[170] = asinh(constants[1]) - computed_constants[171] = acosh(constants[1]) - computed_constants[172] = atanh(constants[1]/2.0) - computed_constants[173] = asech(constants[1]) - computed_constants[174] = acsch(constants[1]) - computed_constants[175] = acoth(2.0*constants[1]) - computed_constants[176] = constants[1] if gt_func(constants[1], constants[2]) else nan - computed_constants[177] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] - computed_constants[178] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] if gt_func(constants[6], constants[18]) else constants[179] if gt_func(constants[179], constants[180]) else nan - computed_constants[181] = constants[1] if gt_func(constants[1], constants[2]) else constants[6] if gt_func(constants[6], constants[18]) else constants[179] if gt_func(constants[179], constants[180]) else constants[182] - computed_constants[183] = 123.0+(constants[1] if gt_func(constants[1], constants[2]) else nan) - computed_constants[188] = constants[1] - computed_constants[195] = and_func(constants[1], constants[2])+(constants[2] if gt_func(constants[6], constants[18]) else nan)+constants[179]+and_func(constants[180], constants[182]) - computed_constants[196] = and_func(constants[1], constants[2])-((constants[2] if gt_func(constants[6], constants[18]) else nan)-(constants[179]-(constants[2] if gt_func(constants[6], constants[18]) else nan)))-and_func(constants[180], constants[182]) - computed_constants[197] = and_func(constants[1], constants[2])*(constants[2] if gt_func(constants[6], constants[18]) else nan)*constants[179]*(constants[2] if gt_func(constants[6], constants[18]) else nan)*and_func(constants[180], constants[182]) - computed_constants[198] = and_func(constants[1], constants[2])/((constants[2] if gt_func(constants[6], constants[18]) else nan)/(constants[179]/(constants[2] if gt_func(constants[6], constants[18]) else nan))) - computed_constants[199] = and_func(or_func(constants[1], constants[2]), and_func(xor_func(constants[1], constants[2]), and_func(constants[2] if gt_func(constants[6], constants[18]) else nan, and_func(and_func(and_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), xor_func(constants[1], constants[2])), or_func(constants[1], constants[2]))))) - computed_constants[200] = or_func(and_func(constants[1], constants[2]), or_func(xor_func(constants[1], constants[2]), or_func(constants[2] if gt_func(constants[6], constants[18]) else nan, or_func(or_func(or_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), xor_func(constants[1], constants[2])), and_func(constants[1], constants[2]))))) - computed_constants[201] = xor_func(and_func(constants[1], constants[2]), xor_func(or_func(constants[1], constants[2]), xor_func(constants[2] if gt_func(constants[6], constants[18]) else nan, xor_func(xor_func(xor_func(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), or_func(constants[1], constants[2])), and_func(constants[1], constants[2]))))) - computed_constants[202] = pow(and_func(constants[1], constants[2]), pow(constants[2] if gt_func(constants[6], constants[18]) else nan, pow(pow(constants[179], constants[2] if gt_func(constants[6], constants[18]) else nan), and_func(constants[1], constants[2])))) - computed_constants[203] = pow(pow(pow(and_func(constants[1], constants[2]), 1.0/pow(constants[2] if gt_func(constants[6], constants[18]) else nan, 1.0/constants[179])), 1.0/(constants[2] if gt_func(constants[6], constants[18]) else nan)), 1.0/and_func(constants[1], constants[2])) - computed_constants[204] = -and_func(constants[1], constants[2])+-(constants[2] if gt_func(constants[6], constants[18]) else nan) + computed_constants[0] = eq_func(constants[0], constants[1]) + computed_constants[1] = constants[0]/eq_func(constants[1], constants[1]) + computed_constants[2] = neq_func(constants[0], constants[1]) + computed_constants[3] = constants[0]/neq_func(constants[1], constants[2]) + computed_constants[4] = lt_func(constants[0], constants[1]) + computed_constants[5] = constants[0]/lt_func(constants[1], constants[2]) + computed_constants[6] = leq_func(constants[0], constants[1]) + computed_constants[7] = constants[0]/leq_func(constants[1], constants[2]) + computed_constants[8] = gt_func(constants[0], constants[1]) + computed_constants[9] = constants[0]/gt_func(constants[1], constants[2]) + computed_constants[10] = geq_func(constants[0], constants[1]) + computed_constants[11] = constants[0]/geq_func(constants[1], constants[2]) + computed_constants[12] = and_func(constants[0], constants[1]) + computed_constants[13] = and_func(constants[0], and_func(constants[1], constants[2])) + computed_constants[14] = and_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[15] = and_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) + computed_constants[16] = and_func(constants[0], gt_func(constants[1], constants[2])) + computed_constants[17] = and_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) + computed_constants[18] = and_func(-constants[0], gt_func(constants[1], constants[2])) + computed_constants[19] = and_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[20] = and_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) + computed_constants[21] = and_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) + computed_constants[22] = and_func(lt_func(constants[0], constants[1]), constants[2]) + computed_constants[23] = and_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) + computed_constants[24] = and_func(lt_func(constants[0], constants[1]), -constants[2]) + computed_constants[25] = and_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) + computed_constants[26] = and_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[27] = constants[0]/and_func(constants[1], constants[2]) + computed_constants[28] = or_func(constants[0], constants[1]) + computed_constants[29] = or_func(constants[0], or_func(constants[1], constants[2])) + computed_constants[30] = or_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[31] = or_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) + computed_constants[32] = or_func(constants[0], gt_func(constants[1], constants[2])) + computed_constants[33] = or_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) + computed_constants[34] = or_func(-constants[0], gt_func(constants[1], constants[2])) + computed_constants[35] = or_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[36] = or_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) + computed_constants[37] = or_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) + computed_constants[38] = or_func(lt_func(constants[0], constants[1]), constants[2]) + computed_constants[39] = or_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) + computed_constants[40] = or_func(lt_func(constants[0], constants[1]), -constants[2]) + computed_constants[41] = or_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) + computed_constants[42] = or_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[43] = constants[0]/or_func(constants[1], constants[2]) + computed_constants[44] = xor_func(constants[0], constants[1]) + computed_constants[45] = xor_func(constants[0], xor_func(constants[1], constants[2])) + computed_constants[46] = xor_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[47] = xor_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) + computed_constants[48] = xor_func(constants[0], gt_func(constants[1], constants[2])) + computed_constants[49] = xor_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) + computed_constants[50] = xor_func(-constants[0], gt_func(constants[1], constants[2])) + computed_constants[51] = xor_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) + computed_constants[52] = xor_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) + computed_constants[53] = xor_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) + computed_constants[54] = xor_func(lt_func(constants[0], constants[1]), constants[2]) + computed_constants[55] = xor_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) + computed_constants[56] = xor_func(lt_func(constants[0], constants[1]), -constants[2]) + computed_constants[57] = xor_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) + computed_constants[58] = xor_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[59] = constants[0]/xor_func(constants[1], constants[2]) + computed_constants[60] = not_func(constants[0]) + computed_constants[61] = constants[0]+constants[1] + computed_constants[62] = constants[0]+constants[1]+constants[2] + computed_constants[63] = lt_func(constants[0], constants[1])+gt_func(constants[2], constants[3]) + computed_constants[64] = constants[0] + computed_constants[65] = constants[0]-constants[1] + computed_constants[66] = lt_func(constants[0], constants[1])-gt_func(constants[2], constants[3]) + computed_constants[67] = lt_func(constants[0], constants[1])-(constants[2]+constants[3]) + computed_constants[68] = lt_func(constants[0], constants[1])-constants[2] + computed_constants[69] = constants[0]-(-constants[1]) + computed_constants[70] = constants[0]-(-constants[1]*constants[2]) + computed_constants[71] = -constants[0] + computed_constants[72] = -lt_func(constants[0], constants[1]) + computed_constants[73] = constants[0]*constants[1] + computed_constants[74] = constants[0]*constants[1]*constants[2] + computed_constants[75] = lt_func(constants[0], constants[1])*gt_func(constants[2], constants[3]) + computed_constants[76] = (constants[0]+constants[1])*gt_func(constants[2], constants[3]) + computed_constants[77] = constants[0]*gt_func(constants[1], constants[2]) + computed_constants[78] = (constants[0]-constants[1])*gt_func(constants[2], constants[3]) + computed_constants[79] = -constants[0]*gt_func(constants[1], constants[2]) + computed_constants[80] = lt_func(constants[0], constants[1])*(constants[2]+constants[3]) + computed_constants[81] = lt_func(constants[0], constants[1])*constants[2] + computed_constants[82] = lt_func(constants[0], constants[1])*(constants[2]-constants[3]) + computed_constants[83] = lt_func(constants[0], constants[1])*-constants[2] + computed_constants[84] = constants[0]/constants[1] + computed_constants[85] = lt_func(constants[0], constants[1])/gt_func(constants[3], constants[2]) + computed_constants[86] = (constants[0]+constants[1])/gt_func(constants[3], constants[2]) + computed_constants[87] = constants[0]/gt_func(constants[2], constants[1]) + computed_constants[88] = (constants[0]-constants[1])/gt_func(constants[3], constants[2]) + computed_constants[89] = -constants[0]/gt_func(constants[2], constants[1]) + computed_constants[90] = lt_func(constants[0], constants[1])/(constants[2]+constants[3]) + computed_constants[91] = lt_func(constants[0], constants[1])/constants[2] + computed_constants[92] = lt_func(constants[0], constants[1])/(constants[2]-constants[3]) + computed_constants[93] = lt_func(constants[0], constants[1])/-constants[2] + computed_constants[94] = lt_func(constants[0], constants[1])/(constants[2]*constants[3]) + computed_constants[95] = lt_func(constants[0], constants[1])/(constants[2]/constants[3]) + computed_constants[96] = sqrt(constants[0]) + computed_constants[97] = pow(constants[0], 2.0) + computed_constants[98] = pow(constants[0], 3.0) + computed_constants[99] = pow(constants[0], constants[1]) + computed_constants[100] = pow(leq_func(constants[0], constants[1]), geq_func(constants[2], constants[3])) + computed_constants[101] = pow(constants[0]+constants[1], geq_func(constants[2], constants[3])) + computed_constants[102] = pow(constants[0], geq_func(constants[1], constants[2])) + computed_constants[103] = pow(constants[0]-constants[1], geq_func(constants[2], constants[3])) + computed_constants[104] = pow(-constants[0], geq_func(constants[1], constants[2])) + computed_constants[105] = pow(constants[0]*constants[1], geq_func(constants[2], constants[3])) + computed_constants[106] = pow(constants[0]/constants[1], geq_func(constants[2], constants[3])) + computed_constants[107] = pow(leq_func(constants[0], constants[1]), constants[2]+constants[3]) + computed_constants[108] = pow(leq_func(constants[0], constants[1]), constants[2]) + computed_constants[109] = pow(leq_func(constants[0], constants[1]), constants[2]-constants[3]) + computed_constants[110] = pow(leq_func(constants[0], constants[1]), -constants[2]) + computed_constants[111] = pow(leq_func(constants[0], constants[1]), constants[2]*constants[3]) + computed_constants[112] = pow(leq_func(constants[0], constants[1]), constants[2]/constants[3]) + computed_constants[113] = pow(leq_func(constants[0], constants[1]), pow(constants[2], constants[3])) + computed_constants[114] = pow(leq_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[115] = sqrt(constants[0]) + computed_constants[116] = sqrt(constants[0]) + computed_constants[117] = pow(constants[0], 1.0/3.0) + computed_constants[118] = pow(constants[0], 1.0/constants[1]) + computed_constants[119] = pow(lt_func(constants[0], constants[1]), 1.0/gt_func(constants[3], constants[2])) + computed_constants[120] = pow(constants[0]+constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[121] = pow(constants[0], 1.0/gt_func(constants[2], constants[1])) + computed_constants[122] = pow(constants[0]-constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[123] = pow(-constants[0], 1.0/gt_func(constants[2], constants[1])) + computed_constants[124] = pow(constants[0]*constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[125] = pow(constants[0]/constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[126] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]+constants[3])) + computed_constants[127] = pow(lt_func(constants[0], constants[1]), 1.0/constants[2]) + computed_constants[128] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]-constants[3])) + computed_constants[129] = pow(lt_func(constants[0], constants[1]), 1.0/-constants[2]) + computed_constants[130] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]*constants[3])) + computed_constants[131] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]/constants[3])) + computed_constants[132] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])) + computed_constants[133] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])) + computed_constants[134] = fabs(constants[0]) + computed_constants[135] = exp(constants[0]) + computed_constants[136] = log(constants[0]) + computed_constants[137] = log10(constants[0]) + computed_constants[138] = log(constants[0])/log(2.0) + computed_constants[139] = log10(constants[0]) + computed_constants[140] = log(constants[0])/log(constants[1]) + computed_constants[141] = ceil(constants[0]) + computed_constants[142] = floor(constants[0]) + computed_constants[143] = min(constants[0], constants[1]) + computed_constants[144] = min(constants[0], min(constants[1], constants[2])) + computed_constants[145] = max(constants[0], constants[1]) + computed_constants[146] = max(constants[0], max(constants[1], constants[2])) + computed_constants[147] = fmod(constants[0], constants[1]) + computed_constants[148] = sin(constants[0]) + computed_constants[149] = cos(constants[0]) + computed_constants[150] = tan(constants[0]) + computed_constants[151] = sec(constants[0]) + computed_constants[152] = csc(constants[0]) + computed_constants[153] = cot(constants[0]) + computed_constants[154] = sinh(constants[0]) + computed_constants[155] = cosh(constants[0]) + computed_constants[156] = tanh(constants[0]) + computed_constants[157] = sech(constants[0]) + computed_constants[158] = csch(constants[0]) + computed_constants[159] = coth(constants[0]) + computed_constants[160] = asin(constants[0]) + computed_constants[161] = acos(constants[0]) + computed_constants[162] = atan(constants[0]) + computed_constants[163] = asec(constants[0]) + computed_constants[164] = acsc(constants[0]) + computed_constants[165] = acot(constants[0]) + computed_constants[166] = asinh(constants[0]) + computed_constants[167] = acosh(constants[0]) + computed_constants[168] = atanh(constants[0]/2.0) + computed_constants[169] = asech(constants[0]) + computed_constants[170] = acsch(constants[0]) + computed_constants[171] = acoth(2.0*constants[0]) + computed_constants[172] = constants[0] if gt_func(constants[0], constants[1]) else nan + computed_constants[173] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] + computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan + computed_constants[175] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] + computed_constants[176] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) + computed_constants[181] = constants[0] + computed_constants[188] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) + computed_constants[189] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) + computed_constants[190] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) + computed_constants[191] = and_func(constants[0], constants[1])/((constants[1] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[1] if gt_func(constants[2], constants[3]) else nan))) + computed_constants[192] = and_func(or_func(constants[0], constants[1]), and_func(xor_func(constants[0], constants[1]), and_func(constants[1] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), or_func(constants[0], constants[1]))))) + computed_constants[193] = or_func(and_func(constants[0], constants[1]), or_func(xor_func(constants[0], constants[1]), or_func(constants[1] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) + computed_constants[194] = xor_func(and_func(constants[0], constants[1]), xor_func(or_func(constants[0], constants[1]), xor_func(constants[1] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), or_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) + computed_constants[195] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) + computed_constants[196] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) + computed_constants[197] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index 662430389..332ca7406 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -35,12 +35,12 @@ void deleteArray(double *array) void initialiseVariables(double *constants) { - constants[1] = 1.0; + constants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = constants[1]; + computedConstants[0] = constants[0]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index 9b07f9502..491cd5db6 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -29,11 +29,11 @@ def create_variables_array(): def initialise_variables(constants): - constants[1] = 1.0 + constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = constants[1] + computed_constants[0] = constants[0] def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index c08dde32e..3dad3588b 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -68,5 +68,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[1] = rates[0]; + algebraic[0] = rates[0]; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 5e2901ca3..636d498eb 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -55,4 +55,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = rates[0] + algebraic[0] = rates[0] diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 5d3967ab0..7c848f430 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -68,5 +68,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[1] = rates[0]; + algebraic[0] = rates[0]; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 339060053..1b1a4ab6e 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -55,4 +55,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = rates[0] + algebraic[0] = rates[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index cd735eda2..42c4bd5eb 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -68,5 +68,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[1] = 2.0*states[0]; + algebraic[0] = 2.0*states[0]; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index bca3f1f41..1515ba774 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -55,4 +55,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = 2.0*states[0] + algebraic[0] = 2.0*states[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 8836720f3..02fe6c001 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -68,5 +68,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[1] = 2.0*states[0]; + algebraic[0] = 2.0*states[0]; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 409f890e5..25de4def2 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -55,4 +55,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = 2.0*states[0] + algebraic[0] = 2.0*states[0] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 8466d70b1..76b2c4760 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -46,9 +46,9 @@ void objectiveFunction0(double *u, double *f, void *data) { double *variables = ((RootFindingInfo *) data)->variables; - algebraic[3] = u[0]; + algebraic[0] = u[0]; - f[0] = algebraic[3]+computedConstants[0]-(computedConstants[1]+computedConstants[2]); + f[0] = algebraic[0]+computedConstants[0]-(computedConstants[1]+computedConstants[2]); } void findRoot0(double *variables) @@ -56,16 +56,16 @@ void findRoot0(double *variables) RootFindingInfo rfi = { variables }; double u[1]; - u[0] = algebraic[3]; + u[0] = algebraic[0]; nlaSolve(objectiveFunction0, u, 1, &rfi); - algebraic[3] = u[0]; + algebraic[0] = u[0]; } void initialiseVariables(double *constants) { - algebraic[3] = 1.0; + algebraic[0] = 1.0; computedConstants[0] = 3.0; computedConstants[1] = 5.0; computedConstants[2] = 7.0; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index 57c92c1e1..060991c4c 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -40,7 +40,7 @@ void initialiseVariables(double *constants, ExternalVariable externalVariable) computedConstants[0] = 3.0; computedConstants[1] = 5.0; computedConstants[2] = 7.0; - algebraic[3] = externalVariable(variables, 3); + algebraic[0] = externalVariable(variables, 0); } void computeComputedConstants(double *constants, double *computedConstants) @@ -49,5 +49,5 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[3] = externalVariable(variables, 3); + algebraic[0] = externalVariable(variables, 0); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index de574c904..136bed0a6 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -35,7 +35,7 @@ def initialise_variables(constants, external_variable): computed_constants[0] = 3.0 computed_constants[1] = 5.0 computed_constants[2] = 7.0 - algebraic[3] = external_variable(variables, 3) + algebraic[0] = external_variable(variables, 0) def compute_computed_constants(constants, computed_constants): @@ -43,4 +43,4 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - algebraic[3] = external_variable(variables, 3) + algebraic[0] = external_variable(variables, 0) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 646d98b2a..c84ffdf6a 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -36,23 +36,23 @@ def create_variables_array(): def objective_function_0(u, f, data): variables = data[0] - algebraic[3] = u[0] + algebraic[0] = u[0] - f[0] = algebraic[3]+computed_constants[0]-(computed_constants[1]+computed_constants[2]) + f[0] = algebraic[0]+computed_constants[0]-(computed_constants[1]+computed_constants[2]) def find_root_0(variables): u = [nan]*1 - u[0] = algebraic[3] + u[0] = algebraic[0] u = nla_solve(objective_function_0, u, 1, [variables]) - algebraic[3] = u[0] + algebraic[0] = u[0] def initialise_variables(constants): - algebraic[3] = 1.0 + algebraic[0] = 1.0 computed_constants[0] = 3.0 computed_constants[1] = 5.0 computed_constants[2] = 7.0 diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index 209f9dc7b..c628b10ac 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -51,8 +51,8 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[2] = u[0]; algebraic[1] = u[1]; - f[0] = 3.0*computedConstants[3]+2.0*algebraic[1]+algebraic[2]-57.0; - f[1] = computedConstants[3]+3.0*algebraic[1]-algebraic[2]-19.0; + f[0] = 3.0*computedConstants[0]+2.0*algebraic[1]+algebraic[2]-57.0; + f[1] = computedConstants[0]+3.0*algebraic[1]-algebraic[2]-19.0; } void findRoot0(double *variables) @@ -73,13 +73,13 @@ void initialiseVariables(double *constants) { algebraic[1] = 1.0; algebraic[2] = 1.0; - constants[4] = 3.0; - constants[5] = 5.0; + constants[0] = 3.0; + constants[1] = 5.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[3] = 3.0*constants[4]+constants[5]; + computedConstants[0] = 3.0*constants[0]+constants[1]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 2c1c63ab8..083873c38 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -41,8 +41,8 @@ def objective_function_0(u, f, data): algebraic[2] = u[0] algebraic[1] = u[1] - f[0] = 3.0*computed_constants[3]+2.0*algebraic[1]+algebraic[2]-57.0 - f[1] = computed_constants[3]+3.0*algebraic[1]-algebraic[2]-19.0 + f[0] = 3.0*computed_constants[0]+2.0*algebraic[1]+algebraic[2]-57.0 + f[1] = computed_constants[0]+3.0*algebraic[1]-algebraic[2]-19.0 def find_root_0(variables): @@ -60,12 +60,12 @@ def find_root_0(variables): def initialise_variables(constants): algebraic[1] = 1.0 algebraic[2] = 1.0 - constants[4] = 3.0 - constants[5] = 5.0 + constants[0] = 3.0 + constants[1] = 5.0 def compute_computed_constants(constants, computed_constants): - computed_constants[3] = 3.0*constants[4]+constants[5] + computed_constants[0] = 3.0*constants[0]+constants[1] def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index 2802b5299..c7e93bd95 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -48,11 +48,11 @@ void objectiveFunction0(double *u, double *f, void *data) { double *variables = ((RootFindingInfo *) data)->variables; - algebraic[3] = u[0]; - algebraic[4] = u[1]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; - f[0] = 3.0*computedConstants[0]+2.0*algebraic[4]+algebraic[3]-57.0; - f[1] = computedConstants[0]+3.0*algebraic[4]-algebraic[3]-19.0; + f[0] = 3.0*computedConstants[0]+2.0*algebraic[1]+algebraic[0]-57.0; + f[1] = computedConstants[0]+3.0*algebraic[1]-algebraic[0]-19.0; } void findRoot0(double *variables) @@ -60,30 +60,30 @@ void findRoot0(double *variables) RootFindingInfo rfi = { variables }; double u[2]; - u[0] = algebraic[3]; - u[1] = algebraic[4]; + u[0] = algebraic[0]; + u[1] = algebraic[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[3] = u[0]; - algebraic[4] = u[1]; + algebraic[0] = u[0]; + algebraic[1] = u[1]; } void initialiseVariables(double *constants) { - constants[1] = 3.0; - constants[2] = 5.0; - algebraic[3] = 1.0; - algebraic[4] = 1.0; + constants[0] = 3.0; + constants[1] = 5.0; + algebraic[0] = 1.0; + algebraic[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 3.0*constants[1]+constants[2]; + computedConstants[0] = 3.0*constants[0]+constants[1]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) { findRoot0(variables); - algebraic[5] = algebraic[4]+algebraic[3]; + algebraic[2] = algebraic[1]+algebraic[0]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index d6259b2b9..8b965af0b 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -38,36 +38,36 @@ def create_variables_array(): def objective_function_0(u, f, data): variables = data[0] - algebraic[3] = u[0] - algebraic[4] = u[1] + algebraic[0] = u[0] + algebraic[1] = u[1] - f[0] = 3.0*computed_constants[0]+2.0*algebraic[4]+algebraic[3]-57.0 - f[1] = computed_constants[0]+3.0*algebraic[4]-algebraic[3]-19.0 + f[0] = 3.0*computed_constants[0]+2.0*algebraic[1]+algebraic[0]-57.0 + f[1] = computed_constants[0]+3.0*algebraic[1]-algebraic[0]-19.0 def find_root_0(variables): u = [nan]*2 - u[0] = algebraic[3] - u[1] = algebraic[4] + u[0] = algebraic[0] + u[1] = algebraic[1] u = nla_solve(objective_function_0, u, 2, [variables]) - algebraic[3] = u[0] - algebraic[4] = u[1] + algebraic[0] = u[0] + algebraic[1] = u[1] def initialise_variables(constants): - constants[1] = 3.0 - constants[2] = 5.0 - algebraic[3] = 1.0 - algebraic[4] = 1.0 + constants[0] = 3.0 + constants[1] = 5.0 + algebraic[0] = 1.0 + algebraic[1] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 3.0*constants[1]+constants[2] + computed_constants[0] = 3.0*constants[0]+constants[1] def compute_variables(constants, computed_constants, algebraic): find_root_0(variables) - algebraic[5] = algebraic[4]+algebraic[3] + algebraic[2] = algebraic[1]+algebraic[0] diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index 91884cff9..a5db4ad9c 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -37,14 +37,14 @@ void deleteArray(double *array) void initialiseVariables(double *constants) { - constants[1] = 0.01; - constants[2] = 0.0011; + constants[0] = 0.01; + constants[1] = 0.0011; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 1000.0*3.14*constants[2]*constants[2]*constants[1]; - computedConstants[3] = 0.02*computedConstants[0]; + computedConstants[0] = 1000.0*3.14*constants[1]*constants[1]*constants[0]; + computedConstants[1] = 0.02*computedConstants[0]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index bcbef6f85..6c941fc86 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -31,13 +31,13 @@ def create_variables_array(): def initialise_variables(constants): - constants[1] = 0.01 - constants[2] = 0.0011 + constants[0] = 0.01 + constants[1] = 0.0011 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 1000.0*3.14*constants[2]*constants[2]*constants[1] - computed_constants[3] = 0.02*computed_constants[0] + computed_constants[0] = 1000.0*3.14*constants[1]*constants[1]*constants[0] + computed_constants[1] = 0.02*computed_constants[0] def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index ea8cac8cf..f13fcec59 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -37,19 +37,19 @@ def create_variables_array(): def initialise_variables(constants): - constants[1] = 1.1 - constants[2] = 21262500.0 - constants[3] = 150.0 - constants[4] = 3402000.0 - constants[5] = 2.0 - constants[6] = 2902500.0 - constants[7] = 810000.0 - constants[8] = 247140.0 - constants[9] = 2902500.0 + constants[0] = 1.1 + constants[1] = 21262500.0 + constants[2] = 150.0 + constants[3] = 3402000.0 + constants[4] = 2.0 + constants[5] = 2902500.0 + constants[6] = 810000.0 + constants[7] = 247140.0 + constants[8] = 2902500.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = constants[1]*(constants[2]*constants[3]-constants[4]*constants[5])/(constants[6]*constants[5]+constants[9]*constants[3]+constants[8]*constants[5]*constants[3]+constants[7]) + computed_constants[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+constants[8]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 79847cd59..dea2a68ea 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -41,8 +41,8 @@ void initialiseVariables(double *constants) void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[1] = constants[0]+constants[0]; - computedConstants[2] = 0.001*constants[0]+0.001*constants[0]; + computedConstants[0] = constants[0]+constants[0]; + computedConstants[1] = 0.001*constants[0]+0.001*constants[0]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index 8d1f0b000..ec8df9c83 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -34,8 +34,8 @@ def initialise_variables(constants): def compute_computed_constants(constants, computed_constants): - computed_constants[1] = constants[0]+constants[0] - computed_constants[2] = 0.001*constants[0]+0.001*constants[0] + computed_constants[0] = constants[0]+constants[0] + computed_constants[1] = 0.001*constants[0]+0.001*constants[0] def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index aff41afb7..89c29978d 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -79,7 +79,7 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[0] = u[0]; - f[0] = constants[1]-(algebraic[0]+algebraic[2]); + f[0] = constants[0]-(algebraic[0]+algebraic[1]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -101,9 +101,9 @@ void objectiveFunction1(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[6] = u[0]; + algebraic[4] = u[0]; - f[0] = algebraic[4]-(algebraic[5]+algebraic[6]); + f[0] = algebraic[2]-(algebraic[3]+algebraic[4]); } void findRoot1(double voi, double *states, double *rates, double *variables) @@ -111,22 +111,22 @@ void findRoot1(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[6]; + u[0] = algebraic[4]; nlaSolve(objectiveFunction1, u, 1, &rfi); - algebraic[6] = u[0]; + algebraic[4] = u[0]; } void initialiseVariables(double *states, double *rates, double *constants) { algebraic[0] = 0.0; + constants[0] = 1.0; constants[1] = 1.0; - constants[3] = 1.0; - algebraic[6] = 0.0; - constants[7] = 20.0; - constants[8] = 2.0; - constants[9] = 10.0; + algebraic[4] = 0.0; + constants[2] = 20.0; + constants[3] = 2.0; + constants[4] = 10.0; states[0] = 1.0; states[1] = 0.0; } @@ -137,20 +137,20 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[2] = states[1]+constants[3]; + algebraic[1] = states[1]+constants[1]; findRoot0(voi, states, rates, variables); rates[0] = algebraic[0]; - algebraic[4] = states[0]/constants[7]; - algebraic[5] = constants[8]*algebraic[2]; + algebraic[2] = states[0]/constants[2]; + algebraic[3] = constants[3]*algebraic[1]; findRoot1(voi, states, rates, variables); - rates[1] = algebraic[6]/constants[9]; + rates[1] = algebraic[4]/constants[4]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[2] = states[1]+constants[3]; + algebraic[1] = states[1]+constants[1]; findRoot0(voi, states, rates, variables); - algebraic[4] = states[0]/constants[7]; - algebraic[5] = constants[8]*algebraic[2]; + algebraic[2] = states[0]/constants[2]; + algebraic[3] = constants[3]*algebraic[1]; findRoot1(voi, states, rates, variables); } diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 764fb8703..c1147dd4f 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -61,7 +61,7 @@ def objective_function_0(u, f, data): algebraic[0] = u[0] - f[0] = constants[1]-(algebraic[0]+algebraic[2]) + f[0] = constants[0]-(algebraic[0]+algebraic[1]) def find_root_0(voi, states, rates, variables): @@ -80,29 +80,29 @@ def objective_function_1(u, f, data): rates = data[2] variables = data[3] - algebraic[6] = u[0] + algebraic[4] = u[0] - f[0] = algebraic[4]-(algebraic[5]+algebraic[6]) + f[0] = algebraic[2]-(algebraic[3]+algebraic[4]) def find_root_1(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[6] + u[0] = algebraic[4] u = nla_solve(objective_function_1, u, 1, [voi, states, rates, variables]) - algebraic[6] = u[0] + algebraic[4] = u[0] def initialise_variables(states, rates, constants): algebraic[0] = 0.0 + constants[0] = 1.0 constants[1] = 1.0 - constants[3] = 1.0 - algebraic[6] = 0.0 - constants[7] = 20.0 - constants[8] = 2.0 - constants[9] = 10.0 + algebraic[4] = 0.0 + constants[2] = 20.0 + constants[3] = 2.0 + constants[4] = 10.0 states[0] = 1.0 states[1] = 0.0 @@ -112,18 +112,18 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[2] = states[1]+constants[3] + algebraic[1] = states[1]+constants[1] find_root_0(voi, states, rates, variables) rates[0] = algebraic[0] - algebraic[4] = states[0]/constants[7] - algebraic[5] = constants[8]*algebraic[2] + algebraic[2] = states[0]/constants[2] + algebraic[3] = constants[3]*algebraic[1] find_root_1(voi, states, rates, variables) - rates[1] = algebraic[6]/constants[9] + rates[1] = algebraic[4]/constants[4] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[2] = states[1]+constants[3] + algebraic[1] = states[1]+constants[1] find_root_0(voi, states, rates, variables) - algebraic[4] = states[0]/constants[7] - algebraic[5] = constants[8]*algebraic[2] + algebraic[2] = states[0]/constants[2] + algebraic[3] = constants[3]*algebraic[1] find_root_1(voi, states, rates, variables) diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index ccb8d7ddf..bfbc945a4 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -302,95 +302,95 @@ void initialiseVariables(double *states, double *rates, double *constants) { constants[0] = 0.0; constants[1] = 0.0; + constants[2] = 140.0; + constants[3] = 5.4; constants[4] = 140.0; - constants[7] = 5.4; - constants[8] = 140.0; - constants[10] = 1.8; - constants[11] = 1.0; - constants[17] = 96485.3415; - constants[22] = 14.0; - constants[23] = 1.4; - constants[24] = 0.08105; - constants[25] = 0.0; - constants[30] = 3.343; - constants[39] = 26.44; - constants[40] = 0.0207; - constants[41] = 0.1369; - constants[43] = 395.3; - constants[44] = 2.289; - constants[45] = 0.4315; - constants[46] = 26.44; - constants[47] = 4.663; - constants[48] = 3.663; - constants[49] = 0.0; - constants[51] = 1628.0; - constants[52] = 561.4; - constants[54] = 148041085.1; - constants[57] = 15.0; - constants[58] = 1.0; - constants[59] = 0.45; - constants[60] = 2.5; - constants[62] = 10000.0; - constants[64] = 500.0; - constants[65] = 5.0; - constants[66] = 660.0; - constants[70] = 5.0; - constants[72] = 5.469e-5; - constants[74] = 0.000286113; - constants[75] = 5.0e-5; - constants[77] = 0.04; - constants[79] = 88800.0; - constants[80] = 446.0; - constants[82] = 227700.0; - constants[83] = 7.51; - constants[85] = 2277.0; - constants[86] = 2.5; - constants[87] = 751.0; - constants[89] = 1.642e6; - constants[90] = 542.0; - constants[93] = 175.4; - constants[94] = 445.0; - constants[95] = 0.031; - constants[96] = 0.062; - constants[97] = 0.045; - constants[98] = 10.0; - constants[104] = 67.0; - constants[105] = 3.9; - constants[106] = 0.02; - constants[107] = 0.0012; - constants[108] = 0.46; - constants[109] = 0.0116; - constants[118] = 5.7e-5; - constants[119] = 8314.472; - constants[120] = 310.0; - constants[122] = 0.0; - constants[123] = -35.0; - constants[124] = 0.5; - constants[125] = 0.5; - constants[126] = -45.0; - constants[128] = 0.00427; - constants[129] = 45.0; - constants[131] = 0.5927; - constants[135] = 0.0; - constants[141] = 0.0; - constants[144] = 0.0223; - constants[146] = 0.0; - constants[150] = 1.0e-5; - constants[157] = 0.1539e-3; - constants[163] = 0.4578; - constants[169] = -16.4508; - constants[170] = 4.3371; - constants[177] = 0.0; - constants[178] = 0.0; - constants[181] = 0.000338; - constants[183] = 0.0075; - constants[184] = 0.04132; - constants[189] = 0.0; - constants[190] = 3.5e-3; - constants[195] = 0.00424; - constants[204] = 0.00065; - constants[211] = 1.0; - constants[212] = 0.00345; + constants[5] = 1.8; + constants[6] = 1.0; + constants[7] = 96485.3415; + constants[8] = 14.0; + constants[9] = 1.4; + constants[10] = 0.08105; + constants[11] = 0.0; + constants[12] = 3.343; + constants[13] = 26.44; + constants[14] = 0.0207; + constants[15] = 0.1369; + constants[16] = 395.3; + constants[17] = 2.289; + constants[18] = 0.4315; + constants[19] = 26.44; + constants[20] = 4.663; + constants[21] = 3.663; + constants[22] = 0.0; + constants[23] = 1628.0; + constants[24] = 561.4; + constants[25] = 148041085.1; + constants[26] = 15.0; + constants[27] = 1.0; + constants[28] = 0.45; + constants[29] = 2.5; + constants[30] = 10000.0; + constants[31] = 500.0; + constants[32] = 5.0; + constants[33] = 660.0; + constants[34] = 5.0; + constants[35] = 5.469e-5; + constants[36] = 0.000286113; + constants[37] = 5.0e-5; + constants[38] = 0.04; + constants[39] = 88800.0; + constants[40] = 446.0; + constants[41] = 227700.0; + constants[42] = 7.51; + constants[43] = 2277.0; + constants[44] = 2.5; + constants[45] = 751.0; + constants[46] = 1.642e6; + constants[47] = 542.0; + constants[48] = 175.4; + constants[49] = 445.0; + constants[50] = 0.031; + constants[51] = 0.062; + constants[52] = 0.045; + constants[53] = 10.0; + constants[54] = 67.0; + constants[55] = 3.9; + constants[56] = 0.02; + constants[57] = 0.0012; + constants[58] = 0.46; + constants[59] = 0.0116; + constants[60] = 5.7e-5; + constants[61] = 8314.472; + constants[62] = 310.0; + constants[63] = 0.0; + constants[64] = -35.0; + constants[65] = 0.5; + constants[66] = 0.5; + constants[67] = -45.0; + constants[68] = 0.00427; + constants[69] = 45.0; + constants[70] = 0.5927; + constants[71] = 0.0; + constants[72] = 0.0; + constants[73] = 0.0223; + constants[74] = 0.0; + constants[75] = 1.0e-5; + constants[76] = 0.1539e-3; + constants[77] = 0.4578; + constants[78] = -16.4508; + constants[79] = 4.3371; + constants[80] = 0.0; + constants[81] = 0.0; + constants[82] = 0.000338; + constants[83] = 0.0075; + constants[84] = 0.04132; + constants[85] = 0.0; + constants[86] = 3.5e-3; + constants[87] = 0.00424; + constants[88] = 0.00065; + constants[89] = 1.0; + constants[90] = 0.00345; states[0] = 6.226104e-5; states[1] = 5.0; states[2] = 0.409551; @@ -428,266 +428,266 @@ void initialiseVariables(double *states, double *rates, double *constants) void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[3] = constants[119]*constants[120]/constants[17]; - computedConstants[6] = computedConstants[3]*log(constants[7]/constants[8]); - computedConstants[20] = (constants[1] > 0.0)?1.2:1.0; - computedConstants[35] = constants[4]/(constants[47]+constants[4]); - computedConstants[68] = (constants[1] > 0.0)?-0.25:(constants[0] > 0.0)?0.7*constants[0]/(0.00009+constants[0]):0.0; - computedConstants[69] = constants[70]*(1.0-computedConstants[68]); - computedConstants[103] = 0.000000001*3.14159265358979*pow(constants[105], 2.0)*constants[104]; - computedConstants[19] = 0.000000001*2.0*3.14159265358979*constants[106]*(constants[105]-constants[106]/2.0)*constants[104]; - computedConstants[100] = constants[107]*computedConstants[103]; - computedConstants[18] = constants[108]*computedConstants[103]-computedConstants[19]; - computedConstants[99] = constants[109]*computedConstants[103]; - computedConstants[127] = constants[128]/(constants[7]/(constants[7]+constants[129])); - computedConstants[130] = computedConstants[127]/(constants[131]+1.0); - computedConstants[132] = constants[131]*computedConstants[130]; - computedConstants[133] = computedConstants[132]*constants[7]/(constants[7]+constants[129]); - computedConstants[134] = computedConstants[130]*constants[7]/(constants[7]+constants[129]); - computedConstants[137] = (constants[0] > 0.0)?-1.0-9.898*pow(1.0*constants[0], 0.618)/(pow(1.0*constants[0], 0.618)+0.00122423):0.0; - computedConstants[138] = (constants[1] > 0.0)?7.5:0.0; - computedConstants[162] = (constants[1] > 0.0)?1.23:1.0; - computedConstants[165] = 0.31*constants[0]/(constants[0]+0.00009); - computedConstants[166] = (constants[1] > 0.0)?-8.0:0.0; - computedConstants[167] = (constants[1] > 0.0)?-27.0:0.0; - computedConstants[203] = (constants[1] > 0.0)?1.2*constants[204]:constants[204]; - computedConstants[206] = (constants[1] > 0.0)?-14.0:0.0; - computedConstants[213] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*constants[0], 1.6951))+0.025641; + computedConstants[0] = constants[61]*constants[62]/constants[7]; + computedConstants[1] = computedConstants[0]*log(constants[3]/constants[4]); + computedConstants[4] = (constants[1] > 0.0)?1.2:1.0; + computedConstants[5] = constants[2]/(constants[20]+constants[2]); + computedConstants[6] = (constants[1] > 0.0)?-0.25:(constants[0] > 0.0)?0.7*constants[0]/(0.00009+constants[0]):0.0; + computedConstants[7] = constants[34]*(1.0-computedConstants[6]); + computedConstants[10] = 0.000000001*3.14159265358979*pow(constants[55], 2.0)*constants[54]; + computedConstants[3] = 0.000000001*2.0*3.14159265358979*constants[56]*(constants[55]-constants[56]/2.0)*constants[54]; + computedConstants[9] = constants[57]*computedConstants[10]; + computedConstants[2] = constants[58]*computedConstants[10]-computedConstants[3]; + computedConstants[8] = constants[59]*computedConstants[10]; + computedConstants[11] = constants[68]/(constants[3]/(constants[3]+constants[69])); + computedConstants[12] = computedConstants[11]/(constants[70]+1.0); + computedConstants[13] = constants[70]*computedConstants[12]; + computedConstants[14] = computedConstants[13]*constants[3]/(constants[3]+constants[69]); + computedConstants[15] = computedConstants[12]*constants[3]/(constants[3]+constants[69]); + computedConstants[16] = (constants[0] > 0.0)?-1.0-9.898*pow(1.0*constants[0], 0.618)/(pow(1.0*constants[0], 0.618)+0.00122423):0.0; + computedConstants[17] = (constants[1] > 0.0)?7.5:0.0; + computedConstants[18] = (constants[1] > 0.0)?1.23:1.0; + computedConstants[19] = 0.31*constants[0]/(constants[0]+0.00009); + computedConstants[20] = (constants[1] > 0.0)?-8.0:0.0; + computedConstants[21] = (constants[1] > 0.0)?-27.0:0.0; + computedConstants[22] = (constants[1] > 0.0)?1.2*constants[88]:constants[88]; + computedConstants[23] = (constants[1] > 0.0)?-14.0:0.0; + computedConstants[24] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*constants[0], 1.6951))+0.025641; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[5] = states[1]; - algebraic[142] = computedConstants[3]*log((constants[4]+0.12*constants[7])/(algebraic[5]+0.12*constants[8])); - algebraic[121] = ((voi > constants[124]) && (voi < constants[124]+constants[125]))?constants[123]:constants[126]; - algebraic[21] = (constants[122] >= 1.0)?algebraic[121]:states[15]; - algebraic[143] = constants[144]*pow(states[18], 3.0)*states[17]*(algebraic[21]-algebraic[142]); - algebraic[145] = constants[146]*pow(states[18], 3.0)*(algebraic[21]-algebraic[142]); - algebraic[12] = algebraic[143]+algebraic[145]; - algebraic[15] = 0.0000185*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computedConstants[3])))*(algebraic[5]-constants[4]*exp(-1.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; - algebraic[2] = computedConstants[3]*log(constants[4]/algebraic[5]); - algebraic[16] = states[16]*computedConstants[133]*(algebraic[21]-algebraic[2])*(1.0-constants[135]); - algebraic[14] = computedConstants[20]*constants[24]*pow(1.0+pow(constants[23]/constants[7], 1.2), -1.0)*pow(1.0+pow(constants[22]/algebraic[5], 1.3), -1.0)*pow(1.0+exp(-(algebraic[21]-algebraic[2]+110.0)/20.0), -1.0); - algebraic[50] = 1.0+constants[10]/constants[48]*(1.0+exp(constants[49]*algebraic[21]/computedConstants[3]))+constants[4]/constants[51]*(1.0+constants[4]/constants[52]*(1.0+constants[4]/constants[47])); - algebraic[27] = constants[10]/constants[48]*exp(constants[49]*algebraic[21]/computedConstants[3])/algebraic[50]; - algebraic[42] = 1.0+states[0]/constants[40]*(1.0+exp(-constants[41]*algebraic[21]/computedConstants[3])+algebraic[5]/constants[46])+algebraic[5]/constants[43]*(1.0+algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])); - algebraic[29] = states[0]/constants[40]*exp(-constants[41]*algebraic[21]/computedConstants[3])/algebraic[42]; - algebraic[36] = algebraic[5]/(constants[39]+algebraic[5]); - algebraic[37] = exp(constants[45]*algebraic[21]/(2.0*computedConstants[3])); - algebraic[33] = exp(-constants[45]*algebraic[21]/(2.0*computedConstants[3])); - algebraic[38] = algebraic[5]/constants[43]*algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])*exp(constants[45]*algebraic[21]/(2.0*computedConstants[3]))/algebraic[42]; - algebraic[26] = algebraic[37]*algebraic[36]*(algebraic[38]+algebraic[29])+algebraic[33]*algebraic[29]*(computedConstants[35]+algebraic[37]); - algebraic[34] = constants[4]/constants[51]*constants[4]/constants[52]*(1.0+constants[4]/constants[47])*exp(-constants[45]*algebraic[21]/(2.0*computedConstants[3]))/algebraic[50]; - algebraic[28] = algebraic[33]*computedConstants[35]*(algebraic[34]+algebraic[27])+algebraic[27]*algebraic[37]*(algebraic[36]+algebraic[33]); - algebraic[31] = algebraic[34]*computedConstants[35]*(algebraic[38]+algebraic[29])+algebraic[38]*algebraic[27]*(computedConstants[35]+algebraic[37]); - algebraic[32] = algebraic[38]*algebraic[36]*(algebraic[34]+algebraic[27])+algebraic[29]*algebraic[34]*(algebraic[36]+algebraic[33]); - algebraic[13] = (1.0-constants[25])*constants[30]*(algebraic[26]*algebraic[27]-algebraic[28]*algebraic[29])/(algebraic[28]+algebraic[26]+algebraic[32]+algebraic[31]); - rates[1] = (1.0-constants[11])*-1.0*(algebraic[12]+algebraic[16]+algebraic[15]+3.0*algebraic[14]+3.0*algebraic[13])/(1.0*(computedConstants[18]+computedConstants[19])*constants[17]); - algebraic[56] = constants[57]-(constants[57]-constants[58])/(1.0+pow(constants[59]/states[2], constants[60])); - algebraic[63] = constants[64]*algebraic[56]; - algebraic[61] = constants[62]/algebraic[56]; - rates[4] = constants[65]*states[5]-algebraic[63]*states[0]*states[4]-(algebraic[61]*pow(states[0], 2.0)*states[4]-constants[66]*states[3]); - rates[3] = algebraic[61]*pow(states[0], 2.0)*states[4]-constants[66]*states[3]-(algebraic[63]*states[0]*states[3]-constants[65]*states[6]); - rates[6] = algebraic[63]*states[0]*states[3]-constants[65]*states[6]-(constants[66]*states[6]-algebraic[61]*pow(states[0], 2.0)*states[5]); - rates[5] = constants[66]*states[6]-algebraic[61]*pow(states[0], 2.0)*states[5]-(constants[65]*states[5]-algebraic[63]*states[0]*states[4]); - algebraic[78] = constants[79]*states[7]*(1.0-states[9])-constants[80]*states[9]; - rates[9] = algebraic[78]; - algebraic[81] = constants[82]*states[7]*(1.0-(states[10]+states[11]))-constants[83]*states[10]; - rates[10] = algebraic[81]; - algebraic[84] = constants[85]*constants[86]*(1.0-(states[10]+states[11]))-constants[87]*states[11]; - rates[11] = algebraic[84]; - algebraic[88] = constants[89]*states[7]*(1.0-states[12])-constants[90]*states[12]; - rates[12] = algebraic[88]; - algebraic[91] = constants[89]*states[0]*(1.0-states[13])-constants[90]*states[13]; - rates[13] = algebraic[91]; - algebraic[92] = constants[93]*states[2]*(1.0-states[14])-constants[94]*states[14]; - rates[14] = algebraic[92]; - algebraic[71] = (states[0]-states[7])/constants[72]; - algebraic[73] = computedConstants[69]/(1.0+exp((-states[7]+constants[74])/constants[75])); - rates[7] = 1.0*(algebraic[71]*computedConstants[19]-algebraic[73]*computedConstants[99])/computedConstants[18]-(constants[97]*algebraic[88]+constants[95]*algebraic[78]+constants[96]*algebraic[81]); - algebraic[53] = constants[54]*states[3]*(states[2]-states[0]); - algebraic[101] = 2.0*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)*2.0/computedConstants[3])))*(states[0]-constants[10]*exp(-2.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; - algebraic[102] = 2.0*constants[184]*algebraic[21]/(computedConstants[3]*(1.0-exp(-1.0*algebraic[21]*2.0/computedConstants[3])))*(states[0]-constants[10]*exp(-2.0*algebraic[21]/computedConstants[3]))*states[25]*states[24]; - rates[0] = algebraic[53]*computedConstants[100]/computedConstants[19]-((algebraic[101]+algebraic[102]-2.0*algebraic[13])/(2.0*constants[17]*computedConstants[19])+algebraic[71]+constants[97]*algebraic[91]); - algebraic[76] = (states[8]-states[2])/constants[77]; - rates[8] = algebraic[73]-algebraic[76]*computedConstants[100]/computedConstants[99]; - rates[2] = algebraic[76]-(algebraic[53]+constants[98]*algebraic[92]); - algebraic[136] = states[16]*computedConstants[134]*(algebraic[21]-computedConstants[6])*(1.0-constants[135]); - algebraic[111] = algebraic[16]+algebraic[136]; - algebraic[112] = constants[157]*states[20]*states[19]*(algebraic[21]-computedConstants[6]); - algebraic[113] = (constants[0] > 0.0)?constants[211]*constants[212]*(algebraic[21]-computedConstants[6])*(1.0+exp((algebraic[21]+20.0)/20.0))*states[32]:0.0; - algebraic[164] = 0.000365*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computedConstants[3])))*(constants[8]-constants[7]*exp(-1.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; - algebraic[114] = (algebraic[101]+algebraic[164]+algebraic[15])*(1.0-computedConstants[165])*1.0*computedConstants[162]; - algebraic[115] = constants[190]*(algebraic[21]-computedConstants[6])*states[27]*states[26]; - algebraic[205] = computedConstants[3]*log((constants[7]+0.12*constants[4])/(constants[8]+0.12*algebraic[5])); - algebraic[116] = computedConstants[203]*(algebraic[21]-algebraic[205])*pow(states[31], 2.0); - algebraic[117] = constants[195]*(algebraic[21]-computedConstants[6])*(0.9*states[29]+0.1*states[30])*states[28]; - algebraic[110] = algebraic[111]+algebraic[117]+algebraic[116]+algebraic[115]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[114]+algebraic[102]+algebraic[113]+algebraic[112]; - rates[15] = -algebraic[110]/constants[118]; - algebraic[140] = (algebraic[21] < -(80.0-computedConstants[137]-computedConstants[138]-constants[141]))?0.01329+0.99921/(1.0+exp((algebraic[21]+97.134-computedConstants[137]-computedConstants[138]-constants[141])/8.1752)):0.0002501*exp(-(algebraic[21]-computedConstants[137]-computedConstants[138]-constants[141])/12.861); - algebraic[139] = 1.0/(0.36*(algebraic[21]+148.8-computedConstants[137]-computedConstants[138])/(exp(0.066*(algebraic[21]+148.8-computedConstants[137]-computedConstants[138]))-1.0)+0.1*(algebraic[21]+87.3-computedConstants[137]-computedConstants[138])/(1.0-exp(-0.2*(algebraic[21]+87.3-computedConstants[137]-computedConstants[138]))))-0.054; - rates[16] = (algebraic[140]-states[16])/algebraic[139]; - algebraic[147] = 1.0/(1.0+exp(-(algebraic[21]+42.0504)/8.3106)); - algebraic[148] = algebraic[21]+41.0; - algebraic[149] = (fabs(algebraic[148]) < constants[150])?2000.0:200.0*algebraic[148]/(1.0-exp(-0.1*algebraic[148])); - algebraic[151] = 8000.0*exp(-0.056*(algebraic[21]+66.0)); - algebraic[152] = 1.0/(algebraic[149]+algebraic[151]); - rates[18] = (algebraic[147]-states[18])/algebraic[152]; - algebraic[153] = 1.0/(1.0+exp((algebraic[21]+69.804)/4.4565)); - algebraic[154] = 20.0*exp(-0.125*(algebraic[21]+75.0)); - algebraic[155] = 2000.0/(320.0*exp(-0.1*(algebraic[21]+75.0))+1.0); - algebraic[156] = 1.0/(algebraic[154]+algebraic[155]); - rates[17] = (algebraic[153]-states[17])/algebraic[156]; - algebraic[158] = 1.0/(1.0+exp((algebraic[21]+6.0)/-8.6)); - algebraic[159] = 0.009/(1.0+exp((algebraic[21]+5.0)/12.0))+0.0005; - rates[20] = (algebraic[158]-states[20])/algebraic[159]; - algebraic[160] = 1.0/(1.0+exp((algebraic[21]+7.5)/10.0)); - algebraic[161] = 0.59/(1.0+exp((algebraic[21]+60.0)/10.0))+3.05; - rates[19] = (algebraic[160]-states[19])/algebraic[161]; - algebraic[168] = 1.0/(1.0+exp(-(algebraic[21]-constants[169]-computedConstants[166])/(constants[170]*(1.0+computedConstants[167]/100.0)))); - algebraic[174] = (algebraic[21] == -41.8)?-41.80001:(algebraic[21] == 0.0)?0.0:(algebraic[21] == -6.8)?-6.80001:algebraic[21]; - algebraic[172] = -0.02839*(algebraic[174]+41.8)/(exp(-(algebraic[174]+41.8)/2.5)-1.0)-0.0849*(algebraic[174]+6.8)/(exp(-(algebraic[174]+6.8)/4.8)-1.0); - algebraic[175] = (algebraic[21] == -1.8)?-1.80001:algebraic[21]; - algebraic[173] = 0.01143*(algebraic[175]+1.8)/(exp((algebraic[175]+1.8)/2.5)-1.0); - algebraic[171] = 0.001/(algebraic[172]+algebraic[173]); - rates[23] = (algebraic[168]-states[23])/algebraic[171]; - algebraic[176] = 1.0/(1.0+exp((algebraic[21]+37.4+constants[177])/(5.3+constants[178]))); - algebraic[179] = 0.001*(44.3+230.0*exp(-pow((algebraic[21]+36.0)/10.0, 2.0))); - rates[22] = (algebraic[176]-states[22])/algebraic[179]; - algebraic[180] = constants[181]/(constants[181]+states[0]); - algebraic[182] = 0.001*algebraic[180]/constants[183]; - rates[21] = (algebraic[180]-states[21])/algebraic[182]; - algebraic[185] = 1.0/(1.0+exp(-(algebraic[21]+38.3)/5.5)); - algebraic[186] = 0.001/(1.068*exp((algebraic[21]+38.3)/30.0)+1.068*exp(-(algebraic[21]+38.3)/30.0)); - rates[25] = (algebraic[185]-states[25])/algebraic[186]; - algebraic[187] = 1.0/(1.0+exp((algebraic[21]+58.7)/3.8)); - algebraic[188] = 1.0/(16.67*exp(-(algebraic[21]+75.0)/83.3)+16.67*exp((algebraic[21]+75.0)/15.38))+constants[189]; - rates[24] = (algebraic[187]-states[24])/algebraic[188]; - algebraic[191] = 1.0/(1.0+exp((algebraic[21]+49.0)/13.0)); - algebraic[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[21]+44.0))+0.065*exp(0.1*(algebraic[21]+45.93)))+10.1); - rates[27] = (algebraic[191]-states[27])/algebraic[192]; - algebraic[193] = 1.0/(1.0+exp(-(algebraic[21]-19.3)/15.0)); - algebraic[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[21]+30.61))+0.369*exp(-0.12*(algebraic[21]+23.84)))+2.98); - rates[26] = (algebraic[193]-states[26])/algebraic[194]; - algebraic[198] = 1.0/(1.0+exp(-(algebraic[21]+10.0144)/7.6607)); - algebraic[199] = 0.84655354/(4.2*exp(algebraic[21]/17.0)+0.15*exp(-algebraic[21]/21.6)); - rates[30] = (algebraic[198]-states[30])/algebraic[199]; - algebraic[200] = 1.0/(30.0*exp(algebraic[21]/10.0)+exp(-algebraic[21]/12.0)); - rates[29] = (algebraic[198]-states[29])/algebraic[200]; - algebraic[202] = 1.0/(1.0+exp((algebraic[21]+28.6)/17.1)); - algebraic[201] = 1.0/(100.0*exp(-algebraic[21]/54.645)+656.0*exp(algebraic[21]/106.157)); - rates[28] = (algebraic[202]-states[28])/algebraic[201]; - algebraic[207] = sqrt(1.0/(1.0+exp(-(algebraic[21]+0.6383-computedConstants[206])/10.7071))); - algebraic[209] = 28.0/(1.0+exp(-(algebraic[21]-40.0-computedConstants[206])/3.0)); - algebraic[210] = 1.0*exp(-(algebraic[21]-computedConstants[206]-5.0)/25.0); - algebraic[208] = 1.0/(algebraic[209]+algebraic[210]); - rates[31] = (algebraic[207]-states[31])/algebraic[208]; - algebraic[214] = 10.0*exp(0.0133*(algebraic[21]+40.0)); - algebraic[215] = computedConstants[213]/(computedConstants[213]+algebraic[214]); - algebraic[216] = 1.0/(computedConstants[213]+algebraic[214]); - rates[32] = (algebraic[215]-states[32])/algebraic[216]; + algebraic[1] = states[1]; + algebraic[51] = computedConstants[0]*log((constants[2]+0.12*constants[3])/(algebraic[1]+0.12*constants[4])); + algebraic[47] = ((voi > constants[65]) && (voi < constants[65]+constants[66]))?constants[64]:constants[67]; + algebraic[8] = (constants[63] >= 1.0)?algebraic[47]:states[15]; + algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]); + algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]); + algebraic[3] = algebraic[52]+algebraic[53]; + algebraic[6] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(algebraic[1]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraic[0] = computedConstants[0]*log(constants[2]/algebraic[1]); + algebraic[7] = states[16]*computedConstants[14]*(algebraic[8]-algebraic[0])*(1.0-constants[71]); + algebraic[5] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[3], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[1], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[0]+110.0)/20.0), -1.0); + algebraic[21] = 1.0+constants[5]/constants[21]*(1.0+exp(constants[22]*algebraic[8]/computedConstants[0]))+constants[2]/constants[23]*(1.0+constants[2]/constants[24]*(1.0+constants[2]/constants[20])); + algebraic[10] = constants[5]/constants[21]*exp(constants[22]*algebraic[8]/computedConstants[0])/algebraic[21]; + algebraic[20] = 1.0+states[0]/constants[14]*(1.0+exp(-constants[15]*algebraic[8]/computedConstants[0])+algebraic[1]/constants[19])+algebraic[1]/constants[16]*(1.0+algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])); + algebraic[12] = states[0]/constants[14]*exp(-constants[15]*algebraic[8]/computedConstants[0])/algebraic[20]; + algebraic[17] = algebraic[1]/(constants[13]+algebraic[1]); + algebraic[18] = exp(constants[18]*algebraic[8]/(2.0*computedConstants[0])); + algebraic[15] = exp(-constants[18]*algebraic[8]/(2.0*computedConstants[0])); + algebraic[19] = algebraic[1]/constants[16]*algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])*exp(constants[18]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[20]; + algebraic[9] = algebraic[18]*algebraic[17]*(algebraic[19]+algebraic[12])+algebraic[15]*algebraic[12]*(computedConstants[5]+algebraic[18]); + algebraic[16] = constants[2]/constants[23]*constants[2]/constants[24]*(1.0+constants[2]/constants[20])*exp(-constants[18]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[21]; + algebraic[11] = algebraic[15]*computedConstants[5]*(algebraic[16]+algebraic[10])+algebraic[10]*algebraic[18]*(algebraic[17]+algebraic[15]); + algebraic[13] = algebraic[16]*computedConstants[5]*(algebraic[19]+algebraic[12])+algebraic[19]*algebraic[10]*(computedConstants[5]+algebraic[18]); + algebraic[14] = algebraic[19]*algebraic[17]*(algebraic[16]+algebraic[10])+algebraic[12]*algebraic[16]*(algebraic[17]+algebraic[15]); + algebraic[4] = (1.0-constants[11])*constants[12]*(algebraic[9]*algebraic[10]-algebraic[11]*algebraic[12])/(algebraic[11]+algebraic[9]+algebraic[14]+algebraic[13]); + rates[1] = (1.0-constants[6])*-1.0*(algebraic[3]+algebraic[7]+algebraic[6]+3.0*algebraic[5]+3.0*algebraic[4])/(1.0*(computedConstants[2]+computedConstants[3])*constants[7]); + algebraic[24] = constants[26]-(constants[26]-constants[27])/(1.0+pow(constants[28]/states[2], constants[29])); + algebraic[26] = constants[31]*algebraic[24]; + algebraic[25] = constants[30]/algebraic[24]; + rates[4] = constants[32]*states[5]-algebraic[26]*states[0]*states[4]-(algebraic[25]*pow(states[0], 2.0)*states[4]-constants[33]*states[3]); + rates[3] = algebraic[25]*pow(states[0], 2.0)*states[4]-constants[33]*states[3]-(algebraic[26]*states[0]*states[3]-constants[32]*states[6]); + rates[6] = algebraic[26]*states[0]*states[3]-constants[32]*states[6]-(constants[33]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]); + rates[5] = constants[33]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]-(constants[32]*states[5]-algebraic[26]*states[0]*states[4]); + algebraic[31] = constants[39]*states[7]*(1.0-states[9])-constants[40]*states[9]; + rates[9] = algebraic[31]; + algebraic[32] = constants[41]*states[7]*(1.0-(states[10]+states[11]))-constants[42]*states[10]; + rates[10] = algebraic[32]; + algebraic[33] = constants[43]*constants[44]*(1.0-(states[10]+states[11]))-constants[45]*states[11]; + rates[11] = algebraic[33]; + algebraic[34] = constants[46]*states[7]*(1.0-states[12])-constants[47]*states[12]; + rates[12] = algebraic[34]; + algebraic[35] = constants[46]*states[0]*(1.0-states[13])-constants[47]*states[13]; + rates[13] = algebraic[35]; + algebraic[36] = constants[48]*states[2]*(1.0-states[14])-constants[49]*states[14]; + rates[14] = algebraic[36]; + algebraic[28] = (states[0]-states[7])/constants[35]; + algebraic[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[36])/constants[37])); + rates[7] = 1.0*(algebraic[28]*computedConstants[3]-algebraic[29]*computedConstants[8])/computedConstants[2]-(constants[52]*algebraic[34]+constants[50]*algebraic[31]+constants[51]*algebraic[32]); + algebraic[22] = constants[25]*states[3]*(states[2]-states[0]); + algebraic[37] = 2.0*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraic[38] = 2.0*constants[84]*algebraic[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computedConstants[0]))*states[25]*states[24]; + rates[0] = algebraic[22]*computedConstants[9]/computedConstants[3]-((algebraic[37]+algebraic[38]-2.0*algebraic[4])/(2.0*constants[7]*computedConstants[3])+algebraic[28]+constants[52]*algebraic[35]); + algebraic[30] = (states[8]-states[2])/constants[38]; + rates[8] = algebraic[29]-algebraic[30]*computedConstants[9]/computedConstants[8]; + rates[2] = algebraic[30]-(algebraic[22]+constants[53]*algebraic[36]); + algebraic[48] = states[16]*computedConstants[15]*(algebraic[8]-computedConstants[1])*(1.0-constants[71]); + algebraic[40] = algebraic[7]+algebraic[48]; + algebraic[41] = constants[76]*states[20]*states[19]*(algebraic[8]-computedConstants[1]); + algebraic[42] = (constants[0] > 0.0)?constants[89]*constants[90]*(algebraic[8]-computedConstants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32]:0.0; + algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(constants[4]-constants[3]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraic[43] = (algebraic[37]+algebraic[67]+algebraic[6])*(1.0-computedConstants[19])*1.0*computedConstants[18]; + algebraic[44] = constants[86]*(algebraic[8]-computedConstants[1])*states[27]*states[26]; + algebraic[93] = computedConstants[0]*log((constants[3]+0.12*constants[2])/(constants[4]+0.12*algebraic[1])); + algebraic[45] = computedConstants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0); + algebraic[46] = constants[87]*(algebraic[8]-computedConstants[1])*(0.9*states[29]+0.1*states[30])*states[28]; + algebraic[39] = algebraic[40]+algebraic[46]+algebraic[45]+algebraic[44]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[43]+algebraic[38]+algebraic[42]+algebraic[41]; + rates[15] = -algebraic[39]/constants[60]; + algebraic[50] = (algebraic[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraic[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); + algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17])/(exp(0.066*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17]))-1.0)+0.1*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17]))))-0.054; + rates[16] = (algebraic[50]-states[16])/algebraic[49]; + algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)); + algebraic[55] = algebraic[8]+41.0; + algebraic[56] = (fabs(algebraic[55]) < constants[75])?2000.0:200.0*algebraic[55]/(1.0-exp(-0.1*algebraic[55])); + algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)); + algebraic[58] = 1.0/(algebraic[56]+algebraic[57]); + rates[18] = (algebraic[54]-states[18])/algebraic[58]; + algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)); + algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)); + algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0); + algebraic[62] = 1.0/(algebraic[60]+algebraic[61]); + rates[17] = (algebraic[59]-states[17])/algebraic[62]; + algebraic[63] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)); + algebraic[64] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005; + rates[20] = (algebraic[63]-states[20])/algebraic[64]; + algebraic[65] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)); + algebraic[66] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05; + rates[19] = (algebraic[65]-states[19])/algebraic[66]; + algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[78]-computedConstants[20])/(constants[79]*(1.0+computedConstants[21]/100.0)))); + algebraic[72] = (algebraic[8] == -41.8)?-41.80001:(algebraic[8] == 0.0)?0.0:(algebraic[8] == -6.8)?-6.80001:algebraic[8]; + algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0); + algebraic[73] = (algebraic[8] == -1.8)?-1.80001:algebraic[8]; + algebraic[71] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0); + algebraic[69] = 0.001/(algebraic[70]+algebraic[71]); + rates[23] = (algebraic[68]-states[23])/algebraic[69]; + algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[80])/(5.3+constants[81]))); + algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))); + rates[22] = (algebraic[74]-states[22])/algebraic[75]; + algebraic[76] = constants[82]/(constants[82]+states[0]); + algebraic[77] = 0.001*algebraic[76]/constants[83]; + rates[21] = (algebraic[76]-states[21])/algebraic[77]; + algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)); + algebraic[79] = 0.001/(1.068*exp((algebraic[8]+38.3)/30.0)+1.068*exp(-(algebraic[8]+38.3)/30.0)); + rates[25] = (algebraic[78]-states[25])/algebraic[79]; + algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)); + algebraic[81] = 1.0/(16.67*exp(-(algebraic[8]+75.0)/83.3)+16.67*exp((algebraic[8]+75.0)/15.38))+constants[85]; + rates[24] = (algebraic[80]-states[24])/algebraic[81]; + algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)); + algebraic[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[8]+44.0))+0.065*exp(0.1*(algebraic[8]+45.93)))+10.1); + rates[27] = (algebraic[82]-states[27])/algebraic[83]; + algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)); + algebraic[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[8]+30.61))+0.369*exp(-0.12*(algebraic[8]+23.84)))+2.98); + rates[26] = (algebraic[84]-states[26])/algebraic[85]; + algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)); + algebraic[89] = 0.84655354/(4.2*exp(algebraic[8]/17.0)+0.15*exp(-algebraic[8]/21.6)); + rates[30] = (algebraic[88]-states[30])/algebraic[89]; + algebraic[90] = 1.0/(30.0*exp(algebraic[8]/10.0)+exp(-algebraic[8]/12.0)); + rates[29] = (algebraic[88]-states[29])/algebraic[90]; + algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)); + algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)); + rates[28] = (algebraic[92]-states[28])/algebraic[91]; + algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computedConstants[23])/10.7071))); + algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computedConstants[23])/3.0)); + algebraic[97] = 1.0*exp(-(algebraic[8]-computedConstants[23]-5.0)/25.0); + algebraic[95] = 1.0/(algebraic[96]+algebraic[97]); + rates[31] = (algebraic[94]-states[31])/algebraic[95]; + algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)); + algebraic[99] = computedConstants[24]/(computedConstants[24]+algebraic[98]); + algebraic[100] = 1.0/(computedConstants[24]+algebraic[98]); + rates[32] = (algebraic[99]-states[32])/algebraic[100]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[5] = states[1]; - algebraic[2] = computedConstants[3]*log(constants[4]/algebraic[5]); - algebraic[9] = 0.5*computedConstants[3]*log(constants[10]/states[0]); - algebraic[21] = (constants[122] >= 1.0)?algebraic[121]:states[15]; - algebraic[14] = computedConstants[20]*constants[24]*pow(1.0+pow(constants[23]/constants[7], 1.2), -1.0)*pow(1.0+pow(constants[22]/algebraic[5], 1.3), -1.0)*pow(1.0+exp(-(algebraic[21]-algebraic[2]+110.0)/20.0), -1.0); - algebraic[50] = 1.0+constants[10]/constants[48]*(1.0+exp(constants[49]*algebraic[21]/computedConstants[3]))+constants[4]/constants[51]*(1.0+constants[4]/constants[52]*(1.0+constants[4]/constants[47])); - algebraic[27] = constants[10]/constants[48]*exp(constants[49]*algebraic[21]/computedConstants[3])/algebraic[50]; - algebraic[42] = 1.0+states[0]/constants[40]*(1.0+exp(-constants[41]*algebraic[21]/computedConstants[3])+algebraic[5]/constants[46])+algebraic[5]/constants[43]*(1.0+algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])); - algebraic[29] = states[0]/constants[40]*exp(-constants[41]*algebraic[21]/computedConstants[3])/algebraic[42]; - algebraic[36] = algebraic[5]/(constants[39]+algebraic[5]); - algebraic[37] = exp(constants[45]*algebraic[21]/(2.0*computedConstants[3])); - algebraic[33] = exp(-constants[45]*algebraic[21]/(2.0*computedConstants[3])); - algebraic[38] = algebraic[5]/constants[43]*algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])*exp(constants[45]*algebraic[21]/(2.0*computedConstants[3]))/algebraic[42]; - algebraic[26] = algebraic[37]*algebraic[36]*(algebraic[38]+algebraic[29])+algebraic[33]*algebraic[29]*(computedConstants[35]+algebraic[37]); - algebraic[34] = constants[4]/constants[51]*constants[4]/constants[52]*(1.0+constants[4]/constants[47])*exp(-constants[45]*algebraic[21]/(2.0*computedConstants[3]))/algebraic[50]; - algebraic[28] = algebraic[33]*computedConstants[35]*(algebraic[34]+algebraic[27])+algebraic[27]*algebraic[37]*(algebraic[36]+algebraic[33]); - algebraic[31] = algebraic[34]*computedConstants[35]*(algebraic[38]+algebraic[29])+algebraic[38]*algebraic[27]*(computedConstants[35]+algebraic[37]); - algebraic[32] = algebraic[38]*algebraic[36]*(algebraic[34]+algebraic[27])+algebraic[29]*algebraic[34]*(algebraic[36]+algebraic[33]); - algebraic[13] = (1.0-constants[25])*constants[30]*(algebraic[26]*algebraic[27]-algebraic[28]*algebraic[29])/(algebraic[28]+algebraic[26]+algebraic[32]+algebraic[31]); - algebraic[53] = constants[54]*states[3]*(states[2]-states[0]); - algebraic[55] = states[2]-states[0]; - algebraic[56] = constants[57]-(constants[57]-constants[58])/(1.0+pow(constants[59]/states[2], constants[60])); - algebraic[61] = constants[62]/algebraic[56]; - algebraic[63] = constants[64]*algebraic[56]; - algebraic[67] = states[4]+states[3]+states[6]+states[5]; - algebraic[71] = (states[0]-states[7])/constants[72]; - algebraic[73] = computedConstants[69]/(1.0+exp((-states[7]+constants[74])/constants[75])); - algebraic[76] = (states[8]-states[2])/constants[77]; - algebraic[78] = constants[79]*states[7]*(1.0-states[9])-constants[80]*states[9]; - algebraic[81] = constants[82]*states[7]*(1.0-(states[10]+states[11]))-constants[83]*states[10]; - algebraic[84] = constants[85]*constants[86]*(1.0-(states[10]+states[11]))-constants[87]*states[11]; - algebraic[88] = constants[89]*states[7]*(1.0-states[12])-constants[90]*states[12]; - algebraic[91] = constants[89]*states[0]*(1.0-states[13])-constants[90]*states[13]; - algebraic[92] = constants[93]*states[2]*(1.0-states[14])-constants[94]*states[14]; - algebraic[16] = states[16]*computedConstants[133]*(algebraic[21]-algebraic[2])*(1.0-constants[135]); - algebraic[136] = states[16]*computedConstants[134]*(algebraic[21]-computedConstants[6])*(1.0-constants[135]); - algebraic[111] = algebraic[16]+algebraic[136]; - algebraic[112] = constants[157]*states[20]*states[19]*(algebraic[21]-computedConstants[6]); - algebraic[113] = (constants[0] > 0.0)?constants[211]*constants[212]*(algebraic[21]-computedConstants[6])*(1.0+exp((algebraic[21]+20.0)/20.0))*states[32]:0.0; - algebraic[102] = 2.0*constants[184]*algebraic[21]/(computedConstants[3]*(1.0-exp(-1.0*algebraic[21]*2.0/computedConstants[3])))*(states[0]-constants[10]*exp(-2.0*algebraic[21]/computedConstants[3]))*states[25]*states[24]; - algebraic[101] = 2.0*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)*2.0/computedConstants[3])))*(states[0]-constants[10]*exp(-2.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; - algebraic[15] = 0.0000185*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computedConstants[3])))*(algebraic[5]-constants[4]*exp(-1.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; - algebraic[164] = 0.000365*constants[163]*(algebraic[21]-0.0)/(computedConstants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computedConstants[3])))*(constants[8]-constants[7]*exp(-1.0*(algebraic[21]-0.0)/computedConstants[3]))*states[23]*states[22]*states[21]; - algebraic[114] = (algebraic[101]+algebraic[164]+algebraic[15])*(1.0-computedConstants[165])*1.0*computedConstants[162]; - algebraic[142] = computedConstants[3]*log((constants[4]+0.12*constants[7])/(algebraic[5]+0.12*constants[8])); - algebraic[143] = constants[144]*pow(states[18], 3.0)*states[17]*(algebraic[21]-algebraic[142]); - algebraic[145] = constants[146]*pow(states[18], 3.0)*(algebraic[21]-algebraic[142]); - algebraic[12] = algebraic[143]+algebraic[145]; - algebraic[115] = constants[190]*(algebraic[21]-computedConstants[6])*states[27]*states[26]; - algebraic[205] = computedConstants[3]*log((constants[7]+0.12*constants[4])/(constants[8]+0.12*algebraic[5])); - algebraic[116] = computedConstants[203]*(algebraic[21]-algebraic[205])*pow(states[31], 2.0); - algebraic[117] = constants[195]*(algebraic[21]-computedConstants[6])*(0.9*states[29]+0.1*states[30])*states[28]; - algebraic[110] = algebraic[111]+algebraic[117]+algebraic[116]+algebraic[115]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[114]+algebraic[102]+algebraic[113]+algebraic[112]; - algebraic[139] = 1.0/(0.36*(algebraic[21]+148.8-computedConstants[137]-computedConstants[138])/(exp(0.066*(algebraic[21]+148.8-computedConstants[137]-computedConstants[138]))-1.0)+0.1*(algebraic[21]+87.3-computedConstants[137]-computedConstants[138])/(1.0-exp(-0.2*(algebraic[21]+87.3-computedConstants[137]-computedConstants[138]))))-0.054; - algebraic[140] = (algebraic[21] < -(80.0-computedConstants[137]-computedConstants[138]-constants[141]))?0.01329+0.99921/(1.0+exp((algebraic[21]+97.134-computedConstants[137]-computedConstants[138]-constants[141])/8.1752)):0.0002501*exp(-(algebraic[21]-computedConstants[137]-computedConstants[138]-constants[141])/12.861); - algebraic[147] = 1.0/(1.0+exp(-(algebraic[21]+42.0504)/8.3106)); - algebraic[148] = algebraic[21]+41.0; - algebraic[149] = (fabs(algebraic[148]) < constants[150])?2000.0:200.0*algebraic[148]/(1.0-exp(-0.1*algebraic[148])); - algebraic[151] = 8000.0*exp(-0.056*(algebraic[21]+66.0)); - algebraic[152] = 1.0/(algebraic[149]+algebraic[151]); - algebraic[153] = 1.0/(1.0+exp((algebraic[21]+69.804)/4.4565)); - algebraic[154] = 20.0*exp(-0.125*(algebraic[21]+75.0)); - algebraic[155] = 2000.0/(320.0*exp(-0.1*(algebraic[21]+75.0))+1.0); - algebraic[156] = 1.0/(algebraic[154]+algebraic[155]); - algebraic[158] = 1.0/(1.0+exp((algebraic[21]+6.0)/-8.6)); - algebraic[159] = 0.009/(1.0+exp((algebraic[21]+5.0)/12.0))+0.0005; - algebraic[160] = 1.0/(1.0+exp((algebraic[21]+7.5)/10.0)); - algebraic[161] = 0.59/(1.0+exp((algebraic[21]+60.0)/10.0))+3.05; - algebraic[168] = 1.0/(1.0+exp(-(algebraic[21]-constants[169]-computedConstants[166])/(constants[170]*(1.0+computedConstants[167]/100.0)))); - algebraic[174] = (algebraic[21] == -41.8)?-41.80001:(algebraic[21] == 0.0)?0.0:(algebraic[21] == -6.8)?-6.80001:algebraic[21]; - algebraic[172] = -0.02839*(algebraic[174]+41.8)/(exp(-(algebraic[174]+41.8)/2.5)-1.0)-0.0849*(algebraic[174]+6.8)/(exp(-(algebraic[174]+6.8)/4.8)-1.0); - algebraic[175] = (algebraic[21] == -1.8)?-1.80001:algebraic[21]; - algebraic[173] = 0.01143*(algebraic[175]+1.8)/(exp((algebraic[175]+1.8)/2.5)-1.0); - algebraic[171] = 0.001/(algebraic[172]+algebraic[173]); - algebraic[176] = 1.0/(1.0+exp((algebraic[21]+37.4+constants[177])/(5.3+constants[178]))); - algebraic[179] = 0.001*(44.3+230.0*exp(-pow((algebraic[21]+36.0)/10.0, 2.0))); - algebraic[180] = constants[181]/(constants[181]+states[0]); - algebraic[182] = 0.001*algebraic[180]/constants[183]; - algebraic[185] = 1.0/(1.0+exp(-(algebraic[21]+38.3)/5.5)); - algebraic[186] = 0.001/(1.068*exp((algebraic[21]+38.3)/30.0)+1.068*exp(-(algebraic[21]+38.3)/30.0)); - algebraic[187] = 1.0/(1.0+exp((algebraic[21]+58.7)/3.8)); - algebraic[188] = 1.0/(16.67*exp(-(algebraic[21]+75.0)/83.3)+16.67*exp((algebraic[21]+75.0)/15.38))+constants[189]; - algebraic[191] = 1.0/(1.0+exp((algebraic[21]+49.0)/13.0)); - algebraic[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[21]+44.0))+0.065*exp(0.1*(algebraic[21]+45.93)))+10.1); - algebraic[193] = 1.0/(1.0+exp(-(algebraic[21]-19.3)/15.0)); - algebraic[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[21]+30.61))+0.369*exp(-0.12*(algebraic[21]+23.84)))+2.98); - algebraic[196] = 1.0/(1.0+exp(-(algebraic[21]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraic[21]/11.9)+0.96*exp(-algebraic[21]/18.5))); - algebraic[197] = 4.0*((37.2*exp(algebraic[21]/15.9)+0.96*exp(-algebraic[21]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraic[21]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraic[21]/15.9)+0.96*exp(-algebraic[21]/22.5)))); - algebraic[198] = 1.0/(1.0+exp(-(algebraic[21]+10.0144)/7.6607)); - algebraic[199] = 0.84655354/(4.2*exp(algebraic[21]/17.0)+0.15*exp(-algebraic[21]/21.6)); - algebraic[200] = 1.0/(30.0*exp(algebraic[21]/10.0)+exp(-algebraic[21]/12.0)); - algebraic[201] = 1.0/(100.0*exp(-algebraic[21]/54.645)+656.0*exp(algebraic[21]/106.157)); - algebraic[202] = 1.0/(1.0+exp((algebraic[21]+28.6)/17.1)); - algebraic[207] = sqrt(1.0/(1.0+exp(-(algebraic[21]+0.6383-computedConstants[206])/10.7071))); - algebraic[209] = 28.0/(1.0+exp(-(algebraic[21]-40.0-computedConstants[206])/3.0)); - algebraic[210] = 1.0*exp(-(algebraic[21]-computedConstants[206]-5.0)/25.0); - algebraic[208] = 1.0/(algebraic[209]+algebraic[210]); - algebraic[214] = 10.0*exp(0.0133*(algebraic[21]+40.0)); - algebraic[215] = computedConstants[213]/(computedConstants[213]+algebraic[214]); - algebraic[216] = 1.0/(computedConstants[213]+algebraic[214]); + algebraic[1] = states[1]; + algebraic[0] = computedConstants[0]*log(constants[2]/algebraic[1]); + algebraic[2] = 0.5*computedConstants[0]*log(constants[5]/states[0]); + algebraic[8] = (constants[63] >= 1.0)?algebraic[47]:states[15]; + algebraic[5] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[3], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[1], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[0]+110.0)/20.0), -1.0); + algebraic[21] = 1.0+constants[5]/constants[21]*(1.0+exp(constants[22]*algebraic[8]/computedConstants[0]))+constants[2]/constants[23]*(1.0+constants[2]/constants[24]*(1.0+constants[2]/constants[20])); + algebraic[10] = constants[5]/constants[21]*exp(constants[22]*algebraic[8]/computedConstants[0])/algebraic[21]; + algebraic[20] = 1.0+states[0]/constants[14]*(1.0+exp(-constants[15]*algebraic[8]/computedConstants[0])+algebraic[1]/constants[19])+algebraic[1]/constants[16]*(1.0+algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])); + algebraic[12] = states[0]/constants[14]*exp(-constants[15]*algebraic[8]/computedConstants[0])/algebraic[20]; + algebraic[17] = algebraic[1]/(constants[13]+algebraic[1]); + algebraic[18] = exp(constants[18]*algebraic[8]/(2.0*computedConstants[0])); + algebraic[15] = exp(-constants[18]*algebraic[8]/(2.0*computedConstants[0])); + algebraic[19] = algebraic[1]/constants[16]*algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])*exp(constants[18]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[20]; + algebraic[9] = algebraic[18]*algebraic[17]*(algebraic[19]+algebraic[12])+algebraic[15]*algebraic[12]*(computedConstants[5]+algebraic[18]); + algebraic[16] = constants[2]/constants[23]*constants[2]/constants[24]*(1.0+constants[2]/constants[20])*exp(-constants[18]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[21]; + algebraic[11] = algebraic[15]*computedConstants[5]*(algebraic[16]+algebraic[10])+algebraic[10]*algebraic[18]*(algebraic[17]+algebraic[15]); + algebraic[13] = algebraic[16]*computedConstants[5]*(algebraic[19]+algebraic[12])+algebraic[19]*algebraic[10]*(computedConstants[5]+algebraic[18]); + algebraic[14] = algebraic[19]*algebraic[17]*(algebraic[16]+algebraic[10])+algebraic[12]*algebraic[16]*(algebraic[17]+algebraic[15]); + algebraic[4] = (1.0-constants[11])*constants[12]*(algebraic[9]*algebraic[10]-algebraic[11]*algebraic[12])/(algebraic[11]+algebraic[9]+algebraic[14]+algebraic[13]); + algebraic[22] = constants[25]*states[3]*(states[2]-states[0]); + algebraic[23] = states[2]-states[0]; + algebraic[24] = constants[26]-(constants[26]-constants[27])/(1.0+pow(constants[28]/states[2], constants[29])); + algebraic[25] = constants[30]/algebraic[24]; + algebraic[26] = constants[31]*algebraic[24]; + algebraic[27] = states[4]+states[3]+states[6]+states[5]; + algebraic[28] = (states[0]-states[7])/constants[35]; + algebraic[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[36])/constants[37])); + algebraic[30] = (states[8]-states[2])/constants[38]; + algebraic[31] = constants[39]*states[7]*(1.0-states[9])-constants[40]*states[9]; + algebraic[32] = constants[41]*states[7]*(1.0-(states[10]+states[11]))-constants[42]*states[10]; + algebraic[33] = constants[43]*constants[44]*(1.0-(states[10]+states[11]))-constants[45]*states[11]; + algebraic[34] = constants[46]*states[7]*(1.0-states[12])-constants[47]*states[12]; + algebraic[35] = constants[46]*states[0]*(1.0-states[13])-constants[47]*states[13]; + algebraic[36] = constants[48]*states[2]*(1.0-states[14])-constants[49]*states[14]; + algebraic[7] = states[16]*computedConstants[14]*(algebraic[8]-algebraic[0])*(1.0-constants[71]); + algebraic[48] = states[16]*computedConstants[15]*(algebraic[8]-computedConstants[1])*(1.0-constants[71]); + algebraic[40] = algebraic[7]+algebraic[48]; + algebraic[41] = constants[76]*states[20]*states[19]*(algebraic[8]-computedConstants[1]); + algebraic[42] = (constants[0] > 0.0)?constants[89]*constants[90]*(algebraic[8]-computedConstants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32]:0.0; + algebraic[38] = 2.0*constants[84]*algebraic[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computedConstants[0]))*states[25]*states[24]; + algebraic[37] = 2.0*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraic[6] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(algebraic[1]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(constants[4]-constants[3]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraic[43] = (algebraic[37]+algebraic[67]+algebraic[6])*(1.0-computedConstants[19])*1.0*computedConstants[18]; + algebraic[51] = computedConstants[0]*log((constants[2]+0.12*constants[3])/(algebraic[1]+0.12*constants[4])); + algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]); + algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]); + algebraic[3] = algebraic[52]+algebraic[53]; + algebraic[44] = constants[86]*(algebraic[8]-computedConstants[1])*states[27]*states[26]; + algebraic[93] = computedConstants[0]*log((constants[3]+0.12*constants[2])/(constants[4]+0.12*algebraic[1])); + algebraic[45] = computedConstants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0); + algebraic[46] = constants[87]*(algebraic[8]-computedConstants[1])*(0.9*states[29]+0.1*states[30])*states[28]; + algebraic[39] = algebraic[40]+algebraic[46]+algebraic[45]+algebraic[44]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[43]+algebraic[38]+algebraic[42]+algebraic[41]; + algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17])/(exp(0.066*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17]))-1.0)+0.1*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17]))))-0.054; + algebraic[50] = (algebraic[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraic[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); + algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)); + algebraic[55] = algebraic[8]+41.0; + algebraic[56] = (fabs(algebraic[55]) < constants[75])?2000.0:200.0*algebraic[55]/(1.0-exp(-0.1*algebraic[55])); + algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)); + algebraic[58] = 1.0/(algebraic[56]+algebraic[57]); + algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)); + algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)); + algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0); + algebraic[62] = 1.0/(algebraic[60]+algebraic[61]); + algebraic[63] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)); + algebraic[64] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005; + algebraic[65] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)); + algebraic[66] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05; + algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[78]-computedConstants[20])/(constants[79]*(1.0+computedConstants[21]/100.0)))); + algebraic[72] = (algebraic[8] == -41.8)?-41.80001:(algebraic[8] == 0.0)?0.0:(algebraic[8] == -6.8)?-6.80001:algebraic[8]; + algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0); + algebraic[73] = (algebraic[8] == -1.8)?-1.80001:algebraic[8]; + algebraic[71] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0); + algebraic[69] = 0.001/(algebraic[70]+algebraic[71]); + algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[80])/(5.3+constants[81]))); + algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))); + algebraic[76] = constants[82]/(constants[82]+states[0]); + algebraic[77] = 0.001*algebraic[76]/constants[83]; + algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)); + algebraic[79] = 0.001/(1.068*exp((algebraic[8]+38.3)/30.0)+1.068*exp(-(algebraic[8]+38.3)/30.0)); + algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)); + algebraic[81] = 1.0/(16.67*exp(-(algebraic[8]+75.0)/83.3)+16.67*exp((algebraic[8]+75.0)/15.38))+constants[85]; + algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)); + algebraic[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[8]+44.0))+0.065*exp(0.1*(algebraic[8]+45.93)))+10.1); + algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)); + algebraic[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[8]+30.61))+0.369*exp(-0.12*(algebraic[8]+23.84)))+2.98); + algebraic[86] = 1.0/(1.0+exp(-(algebraic[8]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraic[8]/11.9)+0.96*exp(-algebraic[8]/18.5))); + algebraic[87] = 4.0*((37.2*exp(algebraic[8]/15.9)+0.96*exp(-algebraic[8]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraic[8]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraic[8]/15.9)+0.96*exp(-algebraic[8]/22.5)))); + algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)); + algebraic[89] = 0.84655354/(4.2*exp(algebraic[8]/17.0)+0.15*exp(-algebraic[8]/21.6)); + algebraic[90] = 1.0/(30.0*exp(algebraic[8]/10.0)+exp(-algebraic[8]/12.0)); + algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)); + algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)); + algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computedConstants[23])/10.7071))); + algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computedConstants[23])/3.0)); + algebraic[97] = 1.0*exp(-(algebraic[8]-computedConstants[23]-5.0)/25.0); + algebraic[95] = 1.0/(algebraic[96]+algebraic[97]); + algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)); + algebraic[99] = computedConstants[24]/(computedConstants[24]+algebraic[98]); + algebraic[100] = 1.0/(computedConstants[24]+algebraic[98]); } diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 109e8280d..3141afa7a 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -311,95 +311,95 @@ def create_variables_array(): def initialise_variables(states, rates, constants): constants[0] = 0.0 constants[1] = 0.0 + constants[2] = 140.0 + constants[3] = 5.4 constants[4] = 140.0 - constants[7] = 5.4 - constants[8] = 140.0 - constants[10] = 1.8 - constants[11] = 1.0 - constants[17] = 96485.3415 - constants[22] = 14.0 - constants[23] = 1.4 - constants[24] = 0.08105 - constants[25] = 0.0 - constants[30] = 3.343 - constants[39] = 26.44 - constants[40] = 0.0207 - constants[41] = 0.1369 - constants[43] = 395.3 - constants[44] = 2.289 - constants[45] = 0.4315 - constants[46] = 26.44 - constants[47] = 4.663 - constants[48] = 3.663 - constants[49] = 0.0 - constants[51] = 1628.0 - constants[52] = 561.4 - constants[54] = 148041085.1 - constants[57] = 15.0 - constants[58] = 1.0 - constants[59] = 0.45 - constants[60] = 2.5 - constants[62] = 10000.0 - constants[64] = 500.0 - constants[65] = 5.0 - constants[66] = 660.0 - constants[70] = 5.0 - constants[72] = 5.469e-5 - constants[74] = 0.000286113 - constants[75] = 5.0e-5 - constants[77] = 0.04 - constants[79] = 88800.0 - constants[80] = 446.0 - constants[82] = 227700.0 - constants[83] = 7.51 - constants[85] = 2277.0 - constants[86] = 2.5 - constants[87] = 751.0 - constants[89] = 1.642e6 - constants[90] = 542.0 - constants[93] = 175.4 - constants[94] = 445.0 - constants[95] = 0.031 - constants[96] = 0.062 - constants[97] = 0.045 - constants[98] = 10.0 - constants[104] = 67.0 - constants[105] = 3.9 - constants[106] = 0.02 - constants[107] = 0.0012 - constants[108] = 0.46 - constants[109] = 0.0116 - constants[118] = 5.7e-5 - constants[119] = 8314.472 - constants[120] = 310.0 - constants[122] = 0.0 - constants[123] = -35.0 - constants[124] = 0.5 - constants[125] = 0.5 - constants[126] = -45.0 - constants[128] = 0.00427 - constants[129] = 45.0 - constants[131] = 0.5927 - constants[135] = 0.0 - constants[141] = 0.0 - constants[144] = 0.0223 - constants[146] = 0.0 - constants[150] = 1.0e-5 - constants[157] = 0.1539e-3 - constants[163] = 0.4578 - constants[169] = -16.4508 - constants[170] = 4.3371 - constants[177] = 0.0 - constants[178] = 0.0 - constants[181] = 0.000338 - constants[183] = 0.0075 - constants[184] = 0.04132 - constants[189] = 0.0 - constants[190] = 3.5e-3 - constants[195] = 0.00424 - constants[204] = 0.00065 - constants[211] = 1.0 - constants[212] = 0.00345 + constants[5] = 1.8 + constants[6] = 1.0 + constants[7] = 96485.3415 + constants[8] = 14.0 + constants[9] = 1.4 + constants[10] = 0.08105 + constants[11] = 0.0 + constants[12] = 3.343 + constants[13] = 26.44 + constants[14] = 0.0207 + constants[15] = 0.1369 + constants[16] = 395.3 + constants[17] = 2.289 + constants[18] = 0.4315 + constants[19] = 26.44 + constants[20] = 4.663 + constants[21] = 3.663 + constants[22] = 0.0 + constants[23] = 1628.0 + constants[24] = 561.4 + constants[25] = 148041085.1 + constants[26] = 15.0 + constants[27] = 1.0 + constants[28] = 0.45 + constants[29] = 2.5 + constants[30] = 10000.0 + constants[31] = 500.0 + constants[32] = 5.0 + constants[33] = 660.0 + constants[34] = 5.0 + constants[35] = 5.469e-5 + constants[36] = 0.000286113 + constants[37] = 5.0e-5 + constants[38] = 0.04 + constants[39] = 88800.0 + constants[40] = 446.0 + constants[41] = 227700.0 + constants[42] = 7.51 + constants[43] = 2277.0 + constants[44] = 2.5 + constants[45] = 751.0 + constants[46] = 1.642e6 + constants[47] = 542.0 + constants[48] = 175.4 + constants[49] = 445.0 + constants[50] = 0.031 + constants[51] = 0.062 + constants[52] = 0.045 + constants[53] = 10.0 + constants[54] = 67.0 + constants[55] = 3.9 + constants[56] = 0.02 + constants[57] = 0.0012 + constants[58] = 0.46 + constants[59] = 0.0116 + constants[60] = 5.7e-5 + constants[61] = 8314.472 + constants[62] = 310.0 + constants[63] = 0.0 + constants[64] = -35.0 + constants[65] = 0.5 + constants[66] = 0.5 + constants[67] = -45.0 + constants[68] = 0.00427 + constants[69] = 45.0 + constants[70] = 0.5927 + constants[71] = 0.0 + constants[72] = 0.0 + constants[73] = 0.0223 + constants[74] = 0.0 + constants[75] = 1.0e-5 + constants[76] = 0.1539e-3 + constants[77] = 0.4578 + constants[78] = -16.4508 + constants[79] = 4.3371 + constants[80] = 0.0 + constants[81] = 0.0 + constants[82] = 0.000338 + constants[83] = 0.0075 + constants[84] = 0.04132 + constants[85] = 0.0 + constants[86] = 3.5e-3 + constants[87] = 0.00424 + constants[88] = 0.00065 + constants[89] = 1.0 + constants[90] = 0.00345 states[0] = 6.226104e-5 states[1] = 5.0 states[2] = 0.409551 @@ -436,263 +436,263 @@ def initialise_variables(states, rates, constants): def compute_computed_constants(constants, computed_constants): - computed_constants[3] = constants[119]*constants[120]/constants[17] - computed_constants[6] = computed_constants[3]*log(constants[7]/constants[8]) - computed_constants[20] = 1.2 if gt_func(constants[1], 0.0) else 1.0 - computed_constants[35] = constants[4]/(constants[47]+constants[4]) - computed_constants[68] = -0.25 if gt_func(constants[1], 0.0) else 0.7*constants[0]/(0.00009+constants[0]) if gt_func(constants[0], 0.0) else 0.0 - computed_constants[69] = constants[70]*(1.0-computed_constants[68]) - computed_constants[103] = 0.000000001*3.14159265358979*pow(constants[105], 2.0)*constants[104] - computed_constants[19] = 0.000000001*2.0*3.14159265358979*constants[106]*(constants[105]-constants[106]/2.0)*constants[104] - computed_constants[100] = constants[107]*computed_constants[103] - computed_constants[18] = constants[108]*computed_constants[103]-computed_constants[19] - computed_constants[99] = constants[109]*computed_constants[103] - computed_constants[127] = constants[128]/(constants[7]/(constants[7]+constants[129])) - computed_constants[130] = computed_constants[127]/(constants[131]+1.0) - computed_constants[132] = constants[131]*computed_constants[130] - computed_constants[133] = computed_constants[132]*constants[7]/(constants[7]+constants[129]) - computed_constants[134] = computed_constants[130]*constants[7]/(constants[7]+constants[129]) - computed_constants[137] = -1.0-9.898*pow(1.0*constants[0], 0.618)/(pow(1.0*constants[0], 0.618)+0.00122423) if gt_func(constants[0], 0.0) else 0.0 - computed_constants[138] = 7.5 if gt_func(constants[1], 0.0) else 0.0 - computed_constants[162] = 1.23 if gt_func(constants[1], 0.0) else 1.0 - computed_constants[165] = 0.31*constants[0]/(constants[0]+0.00009) - computed_constants[166] = -8.0 if gt_func(constants[1], 0.0) else 0.0 - computed_constants[167] = -27.0 if gt_func(constants[1], 0.0) else 0.0 - computed_constants[203] = 1.2*constants[204] if gt_func(constants[1], 0.0) else constants[204] - computed_constants[206] = -14.0 if gt_func(constants[1], 0.0) else 0.0 - computed_constants[213] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*constants[0], 1.6951))+0.025641 + computed_constants[0] = constants[61]*constants[62]/constants[7] + computed_constants[1] = computed_constants[0]*log(constants[3]/constants[4]) + computed_constants[4] = 1.2 if gt_func(constants[1], 0.0) else 1.0 + computed_constants[5] = constants[2]/(constants[20]+constants[2]) + computed_constants[6] = -0.25 if gt_func(constants[1], 0.0) else 0.7*constants[0]/(0.00009+constants[0]) if gt_func(constants[0], 0.0) else 0.0 + computed_constants[7] = constants[34]*(1.0-computed_constants[6]) + computed_constants[10] = 0.000000001*3.14159265358979*pow(constants[55], 2.0)*constants[54] + computed_constants[3] = 0.000000001*2.0*3.14159265358979*constants[56]*(constants[55]-constants[56]/2.0)*constants[54] + computed_constants[9] = constants[57]*computed_constants[10] + computed_constants[2] = constants[58]*computed_constants[10]-computed_constants[3] + computed_constants[8] = constants[59]*computed_constants[10] + computed_constants[11] = constants[68]/(constants[3]/(constants[3]+constants[69])) + computed_constants[12] = computed_constants[11]/(constants[70]+1.0) + computed_constants[13] = constants[70]*computed_constants[12] + computed_constants[14] = computed_constants[13]*constants[3]/(constants[3]+constants[69]) + computed_constants[15] = computed_constants[12]*constants[3]/(constants[3]+constants[69]) + computed_constants[16] = -1.0-9.898*pow(1.0*constants[0], 0.618)/(pow(1.0*constants[0], 0.618)+0.00122423) if gt_func(constants[0], 0.0) else 0.0 + computed_constants[17] = 7.5 if gt_func(constants[1], 0.0) else 0.0 + computed_constants[18] = 1.23 if gt_func(constants[1], 0.0) else 1.0 + computed_constants[19] = 0.31*constants[0]/(constants[0]+0.00009) + computed_constants[20] = -8.0 if gt_func(constants[1], 0.0) else 0.0 + computed_constants[21] = -27.0 if gt_func(constants[1], 0.0) else 0.0 + computed_constants[22] = 1.2*constants[88] if gt_func(constants[1], 0.0) else constants[88] + computed_constants[23] = -14.0 if gt_func(constants[1], 0.0) else 0.0 + computed_constants[24] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*constants[0], 1.6951))+0.025641 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[5] = states[1] - algebraic[142] = computed_constants[3]*log((constants[4]+0.12*constants[7])/(algebraic[5]+0.12*constants[8])) - algebraic[121] = constants[123] if and_func(gt_func(voi, constants[124]), lt_func(voi, constants[124]+constants[125])) else constants[126] - algebraic[21] = algebraic[121] if geq_func(constants[122], 1.0) else states[15] - algebraic[143] = constants[144]*pow(states[18], 3.0)*states[17]*(algebraic[21]-algebraic[142]) - algebraic[145] = constants[146]*pow(states[18], 3.0)*(algebraic[21]-algebraic[142]) - algebraic[12] = algebraic[143]+algebraic[145] - algebraic[15] = 0.0000185*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computed_constants[3])))*(algebraic[5]-constants[4]*exp(-1.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] - algebraic[2] = computed_constants[3]*log(constants[4]/algebraic[5]) - algebraic[16] = states[16]*computed_constants[133]*(algebraic[21]-algebraic[2])*(1.0-constants[135]) - algebraic[14] = computed_constants[20]*constants[24]*pow(1.0+pow(constants[23]/constants[7], 1.2), -1.0)*pow(1.0+pow(constants[22]/algebraic[5], 1.3), -1.0)*pow(1.0+exp(-(algebraic[21]-algebraic[2]+110.0)/20.0), -1.0) - algebraic[50] = 1.0+constants[10]/constants[48]*(1.0+exp(constants[49]*algebraic[21]/computed_constants[3]))+constants[4]/constants[51]*(1.0+constants[4]/constants[52]*(1.0+constants[4]/constants[47])) - algebraic[27] = constants[10]/constants[48]*exp(constants[49]*algebraic[21]/computed_constants[3])/algebraic[50] - algebraic[42] = 1.0+states[0]/constants[40]*(1.0+exp(-constants[41]*algebraic[21]/computed_constants[3])+algebraic[5]/constants[46])+algebraic[5]/constants[43]*(1.0+algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])) - algebraic[29] = states[0]/constants[40]*exp(-constants[41]*algebraic[21]/computed_constants[3])/algebraic[42] - algebraic[36] = algebraic[5]/(constants[39]+algebraic[5]) - algebraic[37] = exp(constants[45]*algebraic[21]/(2.0*computed_constants[3])) - algebraic[33] = exp(-constants[45]*algebraic[21]/(2.0*computed_constants[3])) - algebraic[38] = algebraic[5]/constants[43]*algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])*exp(constants[45]*algebraic[21]/(2.0*computed_constants[3]))/algebraic[42] - algebraic[26] = algebraic[37]*algebraic[36]*(algebraic[38]+algebraic[29])+algebraic[33]*algebraic[29]*(computed_constants[35]+algebraic[37]) - algebraic[34] = constants[4]/constants[51]*constants[4]/constants[52]*(1.0+constants[4]/constants[47])*exp(-constants[45]*algebraic[21]/(2.0*computed_constants[3]))/algebraic[50] - algebraic[28] = algebraic[33]*computed_constants[35]*(algebraic[34]+algebraic[27])+algebraic[27]*algebraic[37]*(algebraic[36]+algebraic[33]) - algebraic[31] = algebraic[34]*computed_constants[35]*(algebraic[38]+algebraic[29])+algebraic[38]*algebraic[27]*(computed_constants[35]+algebraic[37]) - algebraic[32] = algebraic[38]*algebraic[36]*(algebraic[34]+algebraic[27])+algebraic[29]*algebraic[34]*(algebraic[36]+algebraic[33]) - algebraic[13] = (1.0-constants[25])*constants[30]*(algebraic[26]*algebraic[27]-algebraic[28]*algebraic[29])/(algebraic[28]+algebraic[26]+algebraic[32]+algebraic[31]) - rates[1] = (1.0-constants[11])*-1.0*(algebraic[12]+algebraic[16]+algebraic[15]+3.0*algebraic[14]+3.0*algebraic[13])/(1.0*(computed_constants[18]+computed_constants[19])*constants[17]) - algebraic[56] = constants[57]-(constants[57]-constants[58])/(1.0+pow(constants[59]/states[2], constants[60])) - algebraic[63] = constants[64]*algebraic[56] - algebraic[61] = constants[62]/algebraic[56] - rates[4] = constants[65]*states[5]-algebraic[63]*states[0]*states[4]-(algebraic[61]*pow(states[0], 2.0)*states[4]-constants[66]*states[3]) - rates[3] = algebraic[61]*pow(states[0], 2.0)*states[4]-constants[66]*states[3]-(algebraic[63]*states[0]*states[3]-constants[65]*states[6]) - rates[6] = algebraic[63]*states[0]*states[3]-constants[65]*states[6]-(constants[66]*states[6]-algebraic[61]*pow(states[0], 2.0)*states[5]) - rates[5] = constants[66]*states[6]-algebraic[61]*pow(states[0], 2.0)*states[5]-(constants[65]*states[5]-algebraic[63]*states[0]*states[4]) - algebraic[78] = constants[79]*states[7]*(1.0-states[9])-constants[80]*states[9] - rates[9] = algebraic[78] - algebraic[81] = constants[82]*states[7]*(1.0-(states[10]+states[11]))-constants[83]*states[10] - rates[10] = algebraic[81] - algebraic[84] = constants[85]*constants[86]*(1.0-(states[10]+states[11]))-constants[87]*states[11] - rates[11] = algebraic[84] - algebraic[88] = constants[89]*states[7]*(1.0-states[12])-constants[90]*states[12] - rates[12] = algebraic[88] - algebraic[91] = constants[89]*states[0]*(1.0-states[13])-constants[90]*states[13] - rates[13] = algebraic[91] - algebraic[92] = constants[93]*states[2]*(1.0-states[14])-constants[94]*states[14] - rates[14] = algebraic[92] - algebraic[71] = (states[0]-states[7])/constants[72] - algebraic[73] = computed_constants[69]/(1.0+exp((-states[7]+constants[74])/constants[75])) - rates[7] = 1.0*(algebraic[71]*computed_constants[19]-algebraic[73]*computed_constants[99])/computed_constants[18]-(constants[97]*algebraic[88]+constants[95]*algebraic[78]+constants[96]*algebraic[81]) - algebraic[53] = constants[54]*states[3]*(states[2]-states[0]) - algebraic[101] = 2.0*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)*2.0/computed_constants[3])))*(states[0]-constants[10]*exp(-2.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] - algebraic[102] = 2.0*constants[184]*algebraic[21]/(computed_constants[3]*(1.0-exp(-1.0*algebraic[21]*2.0/computed_constants[3])))*(states[0]-constants[10]*exp(-2.0*algebraic[21]/computed_constants[3]))*states[25]*states[24] - rates[0] = algebraic[53]*computed_constants[100]/computed_constants[19]-((algebraic[101]+algebraic[102]-2.0*algebraic[13])/(2.0*constants[17]*computed_constants[19])+algebraic[71]+constants[97]*algebraic[91]) - algebraic[76] = (states[8]-states[2])/constants[77] - rates[8] = algebraic[73]-algebraic[76]*computed_constants[100]/computed_constants[99] - rates[2] = algebraic[76]-(algebraic[53]+constants[98]*algebraic[92]) - algebraic[136] = states[16]*computed_constants[134]*(algebraic[21]-computed_constants[6])*(1.0-constants[135]) - algebraic[111] = algebraic[16]+algebraic[136] - algebraic[112] = constants[157]*states[20]*states[19]*(algebraic[21]-computed_constants[6]) - algebraic[113] = constants[211]*constants[212]*(algebraic[21]-computed_constants[6])*(1.0+exp((algebraic[21]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 - algebraic[164] = 0.000365*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computed_constants[3])))*(constants[8]-constants[7]*exp(-1.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] - algebraic[114] = (algebraic[101]+algebraic[164]+algebraic[15])*(1.0-computed_constants[165])*1.0*computed_constants[162] - algebraic[115] = constants[190]*(algebraic[21]-computed_constants[6])*states[27]*states[26] - algebraic[205] = computed_constants[3]*log((constants[7]+0.12*constants[4])/(constants[8]+0.12*algebraic[5])) - algebraic[116] = computed_constants[203]*(algebraic[21]-algebraic[205])*pow(states[31], 2.0) - algebraic[117] = constants[195]*(algebraic[21]-computed_constants[6])*(0.9*states[29]+0.1*states[30])*states[28] - algebraic[110] = algebraic[111]+algebraic[117]+algebraic[116]+algebraic[115]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[114]+algebraic[102]+algebraic[113]+algebraic[112] - rates[15] = -algebraic[110]/constants[118] - algebraic[140] = 0.01329+0.99921/(1.0+exp((algebraic[21]+97.134-computed_constants[137]-computed_constants[138]-constants[141])/8.1752)) if lt_func(algebraic[21], -(80.0-computed_constants[137]-computed_constants[138]-constants[141])) else 0.0002501*exp(-(algebraic[21]-computed_constants[137]-computed_constants[138]-constants[141])/12.861) - algebraic[139] = 1.0/(0.36*(algebraic[21]+148.8-computed_constants[137]-computed_constants[138])/(exp(0.066*(algebraic[21]+148.8-computed_constants[137]-computed_constants[138]))-1.0)+0.1*(algebraic[21]+87.3-computed_constants[137]-computed_constants[138])/(1.0-exp(-0.2*(algebraic[21]+87.3-computed_constants[137]-computed_constants[138]))))-0.054 - rates[16] = (algebraic[140]-states[16])/algebraic[139] - algebraic[147] = 1.0/(1.0+exp(-(algebraic[21]+42.0504)/8.3106)) - algebraic[148] = algebraic[21]+41.0 - algebraic[149] = 2000.0 if lt_func(fabs(algebraic[148]), constants[150]) else 200.0*algebraic[148]/(1.0-exp(-0.1*algebraic[148])) - algebraic[151] = 8000.0*exp(-0.056*(algebraic[21]+66.0)) - algebraic[152] = 1.0/(algebraic[149]+algebraic[151]) - rates[18] = (algebraic[147]-states[18])/algebraic[152] - algebraic[153] = 1.0/(1.0+exp((algebraic[21]+69.804)/4.4565)) - algebraic[154] = 20.0*exp(-0.125*(algebraic[21]+75.0)) - algebraic[155] = 2000.0/(320.0*exp(-0.1*(algebraic[21]+75.0))+1.0) - algebraic[156] = 1.0/(algebraic[154]+algebraic[155]) - rates[17] = (algebraic[153]-states[17])/algebraic[156] - algebraic[158] = 1.0/(1.0+exp((algebraic[21]+6.0)/-8.6)) - algebraic[159] = 0.009/(1.0+exp((algebraic[21]+5.0)/12.0))+0.0005 - rates[20] = (algebraic[158]-states[20])/algebraic[159] - algebraic[160] = 1.0/(1.0+exp((algebraic[21]+7.5)/10.0)) - algebraic[161] = 0.59/(1.0+exp((algebraic[21]+60.0)/10.0))+3.05 - rates[19] = (algebraic[160]-states[19])/algebraic[161] - algebraic[168] = 1.0/(1.0+exp(-(algebraic[21]-constants[169]-computed_constants[166])/(constants[170]*(1.0+computed_constants[167]/100.0)))) - algebraic[174] = -41.80001 if eq_func(algebraic[21], -41.8) else 0.0 if eq_func(algebraic[21], 0.0) else -6.80001 if eq_func(algebraic[21], -6.8) else algebraic[21] - algebraic[172] = -0.02839*(algebraic[174]+41.8)/(exp(-(algebraic[174]+41.8)/2.5)-1.0)-0.0849*(algebraic[174]+6.8)/(exp(-(algebraic[174]+6.8)/4.8)-1.0) - algebraic[175] = -1.80001 if eq_func(algebraic[21], -1.8) else algebraic[21] - algebraic[173] = 0.01143*(algebraic[175]+1.8)/(exp((algebraic[175]+1.8)/2.5)-1.0) - algebraic[171] = 0.001/(algebraic[172]+algebraic[173]) - rates[23] = (algebraic[168]-states[23])/algebraic[171] - algebraic[176] = 1.0/(1.0+exp((algebraic[21]+37.4+constants[177])/(5.3+constants[178]))) - algebraic[179] = 0.001*(44.3+230.0*exp(-pow((algebraic[21]+36.0)/10.0, 2.0))) - rates[22] = (algebraic[176]-states[22])/algebraic[179] - algebraic[180] = constants[181]/(constants[181]+states[0]) - algebraic[182] = 0.001*algebraic[180]/constants[183] - rates[21] = (algebraic[180]-states[21])/algebraic[182] - algebraic[185] = 1.0/(1.0+exp(-(algebraic[21]+38.3)/5.5)) - algebraic[186] = 0.001/(1.068*exp((algebraic[21]+38.3)/30.0)+1.068*exp(-(algebraic[21]+38.3)/30.0)) - rates[25] = (algebraic[185]-states[25])/algebraic[186] - algebraic[187] = 1.0/(1.0+exp((algebraic[21]+58.7)/3.8)) - algebraic[188] = 1.0/(16.67*exp(-(algebraic[21]+75.0)/83.3)+16.67*exp((algebraic[21]+75.0)/15.38))+constants[189] - rates[24] = (algebraic[187]-states[24])/algebraic[188] - algebraic[191] = 1.0/(1.0+exp((algebraic[21]+49.0)/13.0)) - algebraic[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[21]+44.0))+0.065*exp(0.1*(algebraic[21]+45.93)))+10.1) - rates[27] = (algebraic[191]-states[27])/algebraic[192] - algebraic[193] = 1.0/(1.0+exp(-(algebraic[21]-19.3)/15.0)) - algebraic[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[21]+30.61))+0.369*exp(-0.12*(algebraic[21]+23.84)))+2.98) - rates[26] = (algebraic[193]-states[26])/algebraic[194] - algebraic[198] = 1.0/(1.0+exp(-(algebraic[21]+10.0144)/7.6607)) - algebraic[199] = 0.84655354/(4.2*exp(algebraic[21]/17.0)+0.15*exp(-algebraic[21]/21.6)) - rates[30] = (algebraic[198]-states[30])/algebraic[199] - algebraic[200] = 1.0/(30.0*exp(algebraic[21]/10.0)+exp(-algebraic[21]/12.0)) - rates[29] = (algebraic[198]-states[29])/algebraic[200] - algebraic[202] = 1.0/(1.0+exp((algebraic[21]+28.6)/17.1)) - algebraic[201] = 1.0/(100.0*exp(-algebraic[21]/54.645)+656.0*exp(algebraic[21]/106.157)) - rates[28] = (algebraic[202]-states[28])/algebraic[201] - algebraic[207] = sqrt(1.0/(1.0+exp(-(algebraic[21]+0.6383-computed_constants[206])/10.7071))) - algebraic[209] = 28.0/(1.0+exp(-(algebraic[21]-40.0-computed_constants[206])/3.0)) - algebraic[210] = 1.0*exp(-(algebraic[21]-computed_constants[206]-5.0)/25.0) - algebraic[208] = 1.0/(algebraic[209]+algebraic[210]) - rates[31] = (algebraic[207]-states[31])/algebraic[208] - algebraic[214] = 10.0*exp(0.0133*(algebraic[21]+40.0)) - algebraic[215] = computed_constants[213]/(computed_constants[213]+algebraic[214]) - algebraic[216] = 1.0/(computed_constants[213]+algebraic[214]) - rates[32] = (algebraic[215]-states[32])/algebraic[216] + algebraic[1] = states[1] + algebraic[51] = computed_constants[0]*log((constants[2]+0.12*constants[3])/(algebraic[1]+0.12*constants[4])) + algebraic[47] = constants[64] if and_func(gt_func(voi, constants[65]), lt_func(voi, constants[65]+constants[66])) else constants[67] + algebraic[8] = algebraic[47] if geq_func(constants[63], 1.0) else states[15] + algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]) + algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]) + algebraic[3] = algebraic[52]+algebraic[53] + algebraic[6] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(algebraic[1]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic[0] = computed_constants[0]*log(constants[2]/algebraic[1]) + algebraic[7] = states[16]*computed_constants[14]*(algebraic[8]-algebraic[0])*(1.0-constants[71]) + algebraic[5] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[3], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[1], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[0]+110.0)/20.0), -1.0) + algebraic[21] = 1.0+constants[5]/constants[21]*(1.0+exp(constants[22]*algebraic[8]/computed_constants[0]))+constants[2]/constants[23]*(1.0+constants[2]/constants[24]*(1.0+constants[2]/constants[20])) + algebraic[10] = constants[5]/constants[21]*exp(constants[22]*algebraic[8]/computed_constants[0])/algebraic[21] + algebraic[20] = 1.0+states[0]/constants[14]*(1.0+exp(-constants[15]*algebraic[8]/computed_constants[0])+algebraic[1]/constants[19])+algebraic[1]/constants[16]*(1.0+algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])) + algebraic[12] = states[0]/constants[14]*exp(-constants[15]*algebraic[8]/computed_constants[0])/algebraic[20] + algebraic[17] = algebraic[1]/(constants[13]+algebraic[1]) + algebraic[18] = exp(constants[18]*algebraic[8]/(2.0*computed_constants[0])) + algebraic[15] = exp(-constants[18]*algebraic[8]/(2.0*computed_constants[0])) + algebraic[19] = algebraic[1]/constants[16]*algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])*exp(constants[18]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[20] + algebraic[9] = algebraic[18]*algebraic[17]*(algebraic[19]+algebraic[12])+algebraic[15]*algebraic[12]*(computed_constants[5]+algebraic[18]) + algebraic[16] = constants[2]/constants[23]*constants[2]/constants[24]*(1.0+constants[2]/constants[20])*exp(-constants[18]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[21] + algebraic[11] = algebraic[15]*computed_constants[5]*(algebraic[16]+algebraic[10])+algebraic[10]*algebraic[18]*(algebraic[17]+algebraic[15]) + algebraic[13] = algebraic[16]*computed_constants[5]*(algebraic[19]+algebraic[12])+algebraic[19]*algebraic[10]*(computed_constants[5]+algebraic[18]) + algebraic[14] = algebraic[19]*algebraic[17]*(algebraic[16]+algebraic[10])+algebraic[12]*algebraic[16]*(algebraic[17]+algebraic[15]) + algebraic[4] = (1.0-constants[11])*constants[12]*(algebraic[9]*algebraic[10]-algebraic[11]*algebraic[12])/(algebraic[11]+algebraic[9]+algebraic[14]+algebraic[13]) + rates[1] = (1.0-constants[6])*-1.0*(algebraic[3]+algebraic[7]+algebraic[6]+3.0*algebraic[5]+3.0*algebraic[4])/(1.0*(computed_constants[2]+computed_constants[3])*constants[7]) + algebraic[24] = constants[26]-(constants[26]-constants[27])/(1.0+pow(constants[28]/states[2], constants[29])) + algebraic[26] = constants[31]*algebraic[24] + algebraic[25] = constants[30]/algebraic[24] + rates[4] = constants[32]*states[5]-algebraic[26]*states[0]*states[4]-(algebraic[25]*pow(states[0], 2.0)*states[4]-constants[33]*states[3]) + rates[3] = algebraic[25]*pow(states[0], 2.0)*states[4]-constants[33]*states[3]-(algebraic[26]*states[0]*states[3]-constants[32]*states[6]) + rates[6] = algebraic[26]*states[0]*states[3]-constants[32]*states[6]-(constants[33]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]) + rates[5] = constants[33]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]-(constants[32]*states[5]-algebraic[26]*states[0]*states[4]) + algebraic[31] = constants[39]*states[7]*(1.0-states[9])-constants[40]*states[9] + rates[9] = algebraic[31] + algebraic[32] = constants[41]*states[7]*(1.0-(states[10]+states[11]))-constants[42]*states[10] + rates[10] = algebraic[32] + algebraic[33] = constants[43]*constants[44]*(1.0-(states[10]+states[11]))-constants[45]*states[11] + rates[11] = algebraic[33] + algebraic[34] = constants[46]*states[7]*(1.0-states[12])-constants[47]*states[12] + rates[12] = algebraic[34] + algebraic[35] = constants[46]*states[0]*(1.0-states[13])-constants[47]*states[13] + rates[13] = algebraic[35] + algebraic[36] = constants[48]*states[2]*(1.0-states[14])-constants[49]*states[14] + rates[14] = algebraic[36] + algebraic[28] = (states[0]-states[7])/constants[35] + algebraic[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[36])/constants[37])) + rates[7] = 1.0*(algebraic[28]*computed_constants[3]-algebraic[29]*computed_constants[8])/computed_constants[2]-(constants[52]*algebraic[34]+constants[50]*algebraic[31]+constants[51]*algebraic[32]) + algebraic[22] = constants[25]*states[3]*(states[2]-states[0]) + algebraic[37] = 2.0*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic[38] = 2.0*constants[84]*algebraic[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computed_constants[0]))*states[25]*states[24] + rates[0] = algebraic[22]*computed_constants[9]/computed_constants[3]-((algebraic[37]+algebraic[38]-2.0*algebraic[4])/(2.0*constants[7]*computed_constants[3])+algebraic[28]+constants[52]*algebraic[35]) + algebraic[30] = (states[8]-states[2])/constants[38] + rates[8] = algebraic[29]-algebraic[30]*computed_constants[9]/computed_constants[8] + rates[2] = algebraic[30]-(algebraic[22]+constants[53]*algebraic[36]) + algebraic[48] = states[16]*computed_constants[15]*(algebraic[8]-computed_constants[1])*(1.0-constants[71]) + algebraic[40] = algebraic[7]+algebraic[48] + algebraic[41] = constants[76]*states[20]*states[19]*(algebraic[8]-computed_constants[1]) + algebraic[42] = constants[89]*constants[90]*(algebraic[8]-computed_constants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 + algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(constants[4]-constants[3]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic[43] = (algebraic[37]+algebraic[67]+algebraic[6])*(1.0-computed_constants[19])*1.0*computed_constants[18] + algebraic[44] = constants[86]*(algebraic[8]-computed_constants[1])*states[27]*states[26] + algebraic[93] = computed_constants[0]*log((constants[3]+0.12*constants[2])/(constants[4]+0.12*algebraic[1])) + algebraic[45] = computed_constants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0) + algebraic[46] = constants[87]*(algebraic[8]-computed_constants[1])*(0.9*states[29]+0.1*states[30])*states[28] + algebraic[39] = algebraic[40]+algebraic[46]+algebraic[45]+algebraic[44]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[43]+algebraic[38]+algebraic[42]+algebraic[41] + rates[15] = -algebraic[39]/constants[60] + algebraic[50] = 0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraic[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) + algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17])/(exp(0.066*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17]))-1.0)+0.1*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17]))))-0.054 + rates[16] = (algebraic[50]-states[16])/algebraic[49] + algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)) + algebraic[55] = algebraic[8]+41.0 + algebraic[56] = 2000.0 if lt_func(fabs(algebraic[55]), constants[75]) else 200.0*algebraic[55]/(1.0-exp(-0.1*algebraic[55])) + algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)) + algebraic[58] = 1.0/(algebraic[56]+algebraic[57]) + rates[18] = (algebraic[54]-states[18])/algebraic[58] + algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)) + algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)) + algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0) + algebraic[62] = 1.0/(algebraic[60]+algebraic[61]) + rates[17] = (algebraic[59]-states[17])/algebraic[62] + algebraic[63] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)) + algebraic[64] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005 + rates[20] = (algebraic[63]-states[20])/algebraic[64] + algebraic[65] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)) + algebraic[66] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05 + rates[19] = (algebraic[65]-states[19])/algebraic[66] + algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[78]-computed_constants[20])/(constants[79]*(1.0+computed_constants[21]/100.0)))) + algebraic[72] = -41.80001 if eq_func(algebraic[8], -41.8) else 0.0 if eq_func(algebraic[8], 0.0) else -6.80001 if eq_func(algebraic[8], -6.8) else algebraic[8] + algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0) + algebraic[73] = -1.80001 if eq_func(algebraic[8], -1.8) else algebraic[8] + algebraic[71] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0) + algebraic[69] = 0.001/(algebraic[70]+algebraic[71]) + rates[23] = (algebraic[68]-states[23])/algebraic[69] + algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[80])/(5.3+constants[81]))) + algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))) + rates[22] = (algebraic[74]-states[22])/algebraic[75] + algebraic[76] = constants[82]/(constants[82]+states[0]) + algebraic[77] = 0.001*algebraic[76]/constants[83] + rates[21] = (algebraic[76]-states[21])/algebraic[77] + algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)) + algebraic[79] = 0.001/(1.068*exp((algebraic[8]+38.3)/30.0)+1.068*exp(-(algebraic[8]+38.3)/30.0)) + rates[25] = (algebraic[78]-states[25])/algebraic[79] + algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)) + algebraic[81] = 1.0/(16.67*exp(-(algebraic[8]+75.0)/83.3)+16.67*exp((algebraic[8]+75.0)/15.38))+constants[85] + rates[24] = (algebraic[80]-states[24])/algebraic[81] + algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)) + algebraic[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[8]+44.0))+0.065*exp(0.1*(algebraic[8]+45.93)))+10.1) + rates[27] = (algebraic[82]-states[27])/algebraic[83] + algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)) + algebraic[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[8]+30.61))+0.369*exp(-0.12*(algebraic[8]+23.84)))+2.98) + rates[26] = (algebraic[84]-states[26])/algebraic[85] + algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)) + algebraic[89] = 0.84655354/(4.2*exp(algebraic[8]/17.0)+0.15*exp(-algebraic[8]/21.6)) + rates[30] = (algebraic[88]-states[30])/algebraic[89] + algebraic[90] = 1.0/(30.0*exp(algebraic[8]/10.0)+exp(-algebraic[8]/12.0)) + rates[29] = (algebraic[88]-states[29])/algebraic[90] + algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)) + algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)) + rates[28] = (algebraic[92]-states[28])/algebraic[91] + algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computed_constants[23])/10.7071))) + algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computed_constants[23])/3.0)) + algebraic[97] = 1.0*exp(-(algebraic[8]-computed_constants[23]-5.0)/25.0) + algebraic[95] = 1.0/(algebraic[96]+algebraic[97]) + rates[31] = (algebraic[94]-states[31])/algebraic[95] + algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)) + algebraic[99] = computed_constants[24]/(computed_constants[24]+algebraic[98]) + algebraic[100] = 1.0/(computed_constants[24]+algebraic[98]) + rates[32] = (algebraic[99]-states[32])/algebraic[100] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[5] = states[1] - algebraic[2] = computed_constants[3]*log(constants[4]/algebraic[5]) - algebraic[9] = 0.5*computed_constants[3]*log(constants[10]/states[0]) - algebraic[21] = algebraic[121] if geq_func(constants[122], 1.0) else states[15] - algebraic[14] = computed_constants[20]*constants[24]*pow(1.0+pow(constants[23]/constants[7], 1.2), -1.0)*pow(1.0+pow(constants[22]/algebraic[5], 1.3), -1.0)*pow(1.0+exp(-(algebraic[21]-algebraic[2]+110.0)/20.0), -1.0) - algebraic[50] = 1.0+constants[10]/constants[48]*(1.0+exp(constants[49]*algebraic[21]/computed_constants[3]))+constants[4]/constants[51]*(1.0+constants[4]/constants[52]*(1.0+constants[4]/constants[47])) - algebraic[27] = constants[10]/constants[48]*exp(constants[49]*algebraic[21]/computed_constants[3])/algebraic[50] - algebraic[42] = 1.0+states[0]/constants[40]*(1.0+exp(-constants[41]*algebraic[21]/computed_constants[3])+algebraic[5]/constants[46])+algebraic[5]/constants[43]*(1.0+algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])) - algebraic[29] = states[0]/constants[40]*exp(-constants[41]*algebraic[21]/computed_constants[3])/algebraic[42] - algebraic[36] = algebraic[5]/(constants[39]+algebraic[5]) - algebraic[37] = exp(constants[45]*algebraic[21]/(2.0*computed_constants[3])) - algebraic[33] = exp(-constants[45]*algebraic[21]/(2.0*computed_constants[3])) - algebraic[38] = algebraic[5]/constants[43]*algebraic[5]/constants[44]*(1.0+algebraic[5]/constants[39])*exp(constants[45]*algebraic[21]/(2.0*computed_constants[3]))/algebraic[42] - algebraic[26] = algebraic[37]*algebraic[36]*(algebraic[38]+algebraic[29])+algebraic[33]*algebraic[29]*(computed_constants[35]+algebraic[37]) - algebraic[34] = constants[4]/constants[51]*constants[4]/constants[52]*(1.0+constants[4]/constants[47])*exp(-constants[45]*algebraic[21]/(2.0*computed_constants[3]))/algebraic[50] - algebraic[28] = algebraic[33]*computed_constants[35]*(algebraic[34]+algebraic[27])+algebraic[27]*algebraic[37]*(algebraic[36]+algebraic[33]) - algebraic[31] = algebraic[34]*computed_constants[35]*(algebraic[38]+algebraic[29])+algebraic[38]*algebraic[27]*(computed_constants[35]+algebraic[37]) - algebraic[32] = algebraic[38]*algebraic[36]*(algebraic[34]+algebraic[27])+algebraic[29]*algebraic[34]*(algebraic[36]+algebraic[33]) - algebraic[13] = (1.0-constants[25])*constants[30]*(algebraic[26]*algebraic[27]-algebraic[28]*algebraic[29])/(algebraic[28]+algebraic[26]+algebraic[32]+algebraic[31]) - algebraic[53] = constants[54]*states[3]*(states[2]-states[0]) - algebraic[55] = states[2]-states[0] - algebraic[56] = constants[57]-(constants[57]-constants[58])/(1.0+pow(constants[59]/states[2], constants[60])) - algebraic[61] = constants[62]/algebraic[56] - algebraic[63] = constants[64]*algebraic[56] - algebraic[67] = states[4]+states[3]+states[6]+states[5] - algebraic[71] = (states[0]-states[7])/constants[72] - algebraic[73] = computed_constants[69]/(1.0+exp((-states[7]+constants[74])/constants[75])) - algebraic[76] = (states[8]-states[2])/constants[77] - algebraic[78] = constants[79]*states[7]*(1.0-states[9])-constants[80]*states[9] - algebraic[81] = constants[82]*states[7]*(1.0-(states[10]+states[11]))-constants[83]*states[10] - algebraic[84] = constants[85]*constants[86]*(1.0-(states[10]+states[11]))-constants[87]*states[11] - algebraic[88] = constants[89]*states[7]*(1.0-states[12])-constants[90]*states[12] - algebraic[91] = constants[89]*states[0]*(1.0-states[13])-constants[90]*states[13] - algebraic[92] = constants[93]*states[2]*(1.0-states[14])-constants[94]*states[14] - algebraic[16] = states[16]*computed_constants[133]*(algebraic[21]-algebraic[2])*(1.0-constants[135]) - algebraic[136] = states[16]*computed_constants[134]*(algebraic[21]-computed_constants[6])*(1.0-constants[135]) - algebraic[111] = algebraic[16]+algebraic[136] - algebraic[112] = constants[157]*states[20]*states[19]*(algebraic[21]-computed_constants[6]) - algebraic[113] = constants[211]*constants[212]*(algebraic[21]-computed_constants[6])*(1.0+exp((algebraic[21]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 - algebraic[102] = 2.0*constants[184]*algebraic[21]/(computed_constants[3]*(1.0-exp(-1.0*algebraic[21]*2.0/computed_constants[3])))*(states[0]-constants[10]*exp(-2.0*algebraic[21]/computed_constants[3]))*states[25]*states[24] - algebraic[101] = 2.0*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)*2.0/computed_constants[3])))*(states[0]-constants[10]*exp(-2.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] - algebraic[15] = 0.0000185*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computed_constants[3])))*(algebraic[5]-constants[4]*exp(-1.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] - algebraic[164] = 0.000365*constants[163]*(algebraic[21]-0.0)/(computed_constants[3]*(1.0-exp(-1.0*(algebraic[21]-0.0)/computed_constants[3])))*(constants[8]-constants[7]*exp(-1.0*(algebraic[21]-0.0)/computed_constants[3]))*states[23]*states[22]*states[21] - algebraic[114] = (algebraic[101]+algebraic[164]+algebraic[15])*(1.0-computed_constants[165])*1.0*computed_constants[162] - algebraic[142] = computed_constants[3]*log((constants[4]+0.12*constants[7])/(algebraic[5]+0.12*constants[8])) - algebraic[143] = constants[144]*pow(states[18], 3.0)*states[17]*(algebraic[21]-algebraic[142]) - algebraic[145] = constants[146]*pow(states[18], 3.0)*(algebraic[21]-algebraic[142]) - algebraic[12] = algebraic[143]+algebraic[145] - algebraic[115] = constants[190]*(algebraic[21]-computed_constants[6])*states[27]*states[26] - algebraic[205] = computed_constants[3]*log((constants[7]+0.12*constants[4])/(constants[8]+0.12*algebraic[5])) - algebraic[116] = computed_constants[203]*(algebraic[21]-algebraic[205])*pow(states[31], 2.0) - algebraic[117] = constants[195]*(algebraic[21]-computed_constants[6])*(0.9*states[29]+0.1*states[30])*states[28] - algebraic[110] = algebraic[111]+algebraic[117]+algebraic[116]+algebraic[115]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[114]+algebraic[102]+algebraic[113]+algebraic[112] - algebraic[139] = 1.0/(0.36*(algebraic[21]+148.8-computed_constants[137]-computed_constants[138])/(exp(0.066*(algebraic[21]+148.8-computed_constants[137]-computed_constants[138]))-1.0)+0.1*(algebraic[21]+87.3-computed_constants[137]-computed_constants[138])/(1.0-exp(-0.2*(algebraic[21]+87.3-computed_constants[137]-computed_constants[138]))))-0.054 - algebraic[140] = 0.01329+0.99921/(1.0+exp((algebraic[21]+97.134-computed_constants[137]-computed_constants[138]-constants[141])/8.1752)) if lt_func(algebraic[21], -(80.0-computed_constants[137]-computed_constants[138]-constants[141])) else 0.0002501*exp(-(algebraic[21]-computed_constants[137]-computed_constants[138]-constants[141])/12.861) - algebraic[147] = 1.0/(1.0+exp(-(algebraic[21]+42.0504)/8.3106)) - algebraic[148] = algebraic[21]+41.0 - algebraic[149] = 2000.0 if lt_func(fabs(algebraic[148]), constants[150]) else 200.0*algebraic[148]/(1.0-exp(-0.1*algebraic[148])) - algebraic[151] = 8000.0*exp(-0.056*(algebraic[21]+66.0)) - algebraic[152] = 1.0/(algebraic[149]+algebraic[151]) - algebraic[153] = 1.0/(1.0+exp((algebraic[21]+69.804)/4.4565)) - algebraic[154] = 20.0*exp(-0.125*(algebraic[21]+75.0)) - algebraic[155] = 2000.0/(320.0*exp(-0.1*(algebraic[21]+75.0))+1.0) - algebraic[156] = 1.0/(algebraic[154]+algebraic[155]) - algebraic[158] = 1.0/(1.0+exp((algebraic[21]+6.0)/-8.6)) - algebraic[159] = 0.009/(1.0+exp((algebraic[21]+5.0)/12.0))+0.0005 - algebraic[160] = 1.0/(1.0+exp((algebraic[21]+7.5)/10.0)) - algebraic[161] = 0.59/(1.0+exp((algebraic[21]+60.0)/10.0))+3.05 - algebraic[168] = 1.0/(1.0+exp(-(algebraic[21]-constants[169]-computed_constants[166])/(constants[170]*(1.0+computed_constants[167]/100.0)))) - algebraic[174] = -41.80001 if eq_func(algebraic[21], -41.8) else 0.0 if eq_func(algebraic[21], 0.0) else -6.80001 if eq_func(algebraic[21], -6.8) else algebraic[21] - algebraic[172] = -0.02839*(algebraic[174]+41.8)/(exp(-(algebraic[174]+41.8)/2.5)-1.0)-0.0849*(algebraic[174]+6.8)/(exp(-(algebraic[174]+6.8)/4.8)-1.0) - algebraic[175] = -1.80001 if eq_func(algebraic[21], -1.8) else algebraic[21] - algebraic[173] = 0.01143*(algebraic[175]+1.8)/(exp((algebraic[175]+1.8)/2.5)-1.0) - algebraic[171] = 0.001/(algebraic[172]+algebraic[173]) - algebraic[176] = 1.0/(1.0+exp((algebraic[21]+37.4+constants[177])/(5.3+constants[178]))) - algebraic[179] = 0.001*(44.3+230.0*exp(-pow((algebraic[21]+36.0)/10.0, 2.0))) - algebraic[180] = constants[181]/(constants[181]+states[0]) - algebraic[182] = 0.001*algebraic[180]/constants[183] - algebraic[185] = 1.0/(1.0+exp(-(algebraic[21]+38.3)/5.5)) - algebraic[186] = 0.001/(1.068*exp((algebraic[21]+38.3)/30.0)+1.068*exp(-(algebraic[21]+38.3)/30.0)) - algebraic[187] = 1.0/(1.0+exp((algebraic[21]+58.7)/3.8)) - algebraic[188] = 1.0/(16.67*exp(-(algebraic[21]+75.0)/83.3)+16.67*exp((algebraic[21]+75.0)/15.38))+constants[189] - algebraic[191] = 1.0/(1.0+exp((algebraic[21]+49.0)/13.0)) - algebraic[192] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[21]+44.0))+0.065*exp(0.1*(algebraic[21]+45.93)))+10.1) - algebraic[193] = 1.0/(1.0+exp(-(algebraic[21]-19.3)/15.0)) - algebraic[194] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[21]+30.61))+0.369*exp(-0.12*(algebraic[21]+23.84)))+2.98) - algebraic[196] = 1.0/(1.0+exp(-(algebraic[21]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraic[21]/11.9)+0.96*exp(-algebraic[21]/18.5))) - algebraic[197] = 4.0*((37.2*exp(algebraic[21]/15.9)+0.96*exp(-algebraic[21]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraic[21]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraic[21]/15.9)+0.96*exp(-algebraic[21]/22.5)))) - algebraic[198] = 1.0/(1.0+exp(-(algebraic[21]+10.0144)/7.6607)) - algebraic[199] = 0.84655354/(4.2*exp(algebraic[21]/17.0)+0.15*exp(-algebraic[21]/21.6)) - algebraic[200] = 1.0/(30.0*exp(algebraic[21]/10.0)+exp(-algebraic[21]/12.0)) - algebraic[201] = 1.0/(100.0*exp(-algebraic[21]/54.645)+656.0*exp(algebraic[21]/106.157)) - algebraic[202] = 1.0/(1.0+exp((algebraic[21]+28.6)/17.1)) - algebraic[207] = sqrt(1.0/(1.0+exp(-(algebraic[21]+0.6383-computed_constants[206])/10.7071))) - algebraic[209] = 28.0/(1.0+exp(-(algebraic[21]-40.0-computed_constants[206])/3.0)) - algebraic[210] = 1.0*exp(-(algebraic[21]-computed_constants[206]-5.0)/25.0) - algebraic[208] = 1.0/(algebraic[209]+algebraic[210]) - algebraic[214] = 10.0*exp(0.0133*(algebraic[21]+40.0)) - algebraic[215] = computed_constants[213]/(computed_constants[213]+algebraic[214]) - algebraic[216] = 1.0/(computed_constants[213]+algebraic[214]) + algebraic[1] = states[1] + algebraic[0] = computed_constants[0]*log(constants[2]/algebraic[1]) + algebraic[2] = 0.5*computed_constants[0]*log(constants[5]/states[0]) + algebraic[8] = algebraic[47] if geq_func(constants[63], 1.0) else states[15] + algebraic[5] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[3], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[1], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[0]+110.0)/20.0), -1.0) + algebraic[21] = 1.0+constants[5]/constants[21]*(1.0+exp(constants[22]*algebraic[8]/computed_constants[0]))+constants[2]/constants[23]*(1.0+constants[2]/constants[24]*(1.0+constants[2]/constants[20])) + algebraic[10] = constants[5]/constants[21]*exp(constants[22]*algebraic[8]/computed_constants[0])/algebraic[21] + algebraic[20] = 1.0+states[0]/constants[14]*(1.0+exp(-constants[15]*algebraic[8]/computed_constants[0])+algebraic[1]/constants[19])+algebraic[1]/constants[16]*(1.0+algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])) + algebraic[12] = states[0]/constants[14]*exp(-constants[15]*algebraic[8]/computed_constants[0])/algebraic[20] + algebraic[17] = algebraic[1]/(constants[13]+algebraic[1]) + algebraic[18] = exp(constants[18]*algebraic[8]/(2.0*computed_constants[0])) + algebraic[15] = exp(-constants[18]*algebraic[8]/(2.0*computed_constants[0])) + algebraic[19] = algebraic[1]/constants[16]*algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])*exp(constants[18]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[20] + algebraic[9] = algebraic[18]*algebraic[17]*(algebraic[19]+algebraic[12])+algebraic[15]*algebraic[12]*(computed_constants[5]+algebraic[18]) + algebraic[16] = constants[2]/constants[23]*constants[2]/constants[24]*(1.0+constants[2]/constants[20])*exp(-constants[18]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[21] + algebraic[11] = algebraic[15]*computed_constants[5]*(algebraic[16]+algebraic[10])+algebraic[10]*algebraic[18]*(algebraic[17]+algebraic[15]) + algebraic[13] = algebraic[16]*computed_constants[5]*(algebraic[19]+algebraic[12])+algebraic[19]*algebraic[10]*(computed_constants[5]+algebraic[18]) + algebraic[14] = algebraic[19]*algebraic[17]*(algebraic[16]+algebraic[10])+algebraic[12]*algebraic[16]*(algebraic[17]+algebraic[15]) + algebraic[4] = (1.0-constants[11])*constants[12]*(algebraic[9]*algebraic[10]-algebraic[11]*algebraic[12])/(algebraic[11]+algebraic[9]+algebraic[14]+algebraic[13]) + algebraic[22] = constants[25]*states[3]*(states[2]-states[0]) + algebraic[23] = states[2]-states[0] + algebraic[24] = constants[26]-(constants[26]-constants[27])/(1.0+pow(constants[28]/states[2], constants[29])) + algebraic[25] = constants[30]/algebraic[24] + algebraic[26] = constants[31]*algebraic[24] + algebraic[27] = states[4]+states[3]+states[6]+states[5] + algebraic[28] = (states[0]-states[7])/constants[35] + algebraic[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[36])/constants[37])) + algebraic[30] = (states[8]-states[2])/constants[38] + algebraic[31] = constants[39]*states[7]*(1.0-states[9])-constants[40]*states[9] + algebraic[32] = constants[41]*states[7]*(1.0-(states[10]+states[11]))-constants[42]*states[10] + algebraic[33] = constants[43]*constants[44]*(1.0-(states[10]+states[11]))-constants[45]*states[11] + algebraic[34] = constants[46]*states[7]*(1.0-states[12])-constants[47]*states[12] + algebraic[35] = constants[46]*states[0]*(1.0-states[13])-constants[47]*states[13] + algebraic[36] = constants[48]*states[2]*(1.0-states[14])-constants[49]*states[14] + algebraic[7] = states[16]*computed_constants[14]*(algebraic[8]-algebraic[0])*(1.0-constants[71]) + algebraic[48] = states[16]*computed_constants[15]*(algebraic[8]-computed_constants[1])*(1.0-constants[71]) + algebraic[40] = algebraic[7]+algebraic[48] + algebraic[41] = constants[76]*states[20]*states[19]*(algebraic[8]-computed_constants[1]) + algebraic[42] = constants[89]*constants[90]*(algebraic[8]-computed_constants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 + algebraic[38] = 2.0*constants[84]*algebraic[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computed_constants[0]))*states[25]*states[24] + algebraic[37] = 2.0*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic[6] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(algebraic[1]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(constants[4]-constants[3]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic[43] = (algebraic[37]+algebraic[67]+algebraic[6])*(1.0-computed_constants[19])*1.0*computed_constants[18] + algebraic[51] = computed_constants[0]*log((constants[2]+0.12*constants[3])/(algebraic[1]+0.12*constants[4])) + algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]) + algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]) + algebraic[3] = algebraic[52]+algebraic[53] + algebraic[44] = constants[86]*(algebraic[8]-computed_constants[1])*states[27]*states[26] + algebraic[93] = computed_constants[0]*log((constants[3]+0.12*constants[2])/(constants[4]+0.12*algebraic[1])) + algebraic[45] = computed_constants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0) + algebraic[46] = constants[87]*(algebraic[8]-computed_constants[1])*(0.9*states[29]+0.1*states[30])*states[28] + algebraic[39] = algebraic[40]+algebraic[46]+algebraic[45]+algebraic[44]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[43]+algebraic[38]+algebraic[42]+algebraic[41] + algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17])/(exp(0.066*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17]))-1.0)+0.1*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17]))))-0.054 + algebraic[50] = 0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraic[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) + algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)) + algebraic[55] = algebraic[8]+41.0 + algebraic[56] = 2000.0 if lt_func(fabs(algebraic[55]), constants[75]) else 200.0*algebraic[55]/(1.0-exp(-0.1*algebraic[55])) + algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)) + algebraic[58] = 1.0/(algebraic[56]+algebraic[57]) + algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)) + algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)) + algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0) + algebraic[62] = 1.0/(algebraic[60]+algebraic[61]) + algebraic[63] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)) + algebraic[64] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005 + algebraic[65] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)) + algebraic[66] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05 + algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[78]-computed_constants[20])/(constants[79]*(1.0+computed_constants[21]/100.0)))) + algebraic[72] = -41.80001 if eq_func(algebraic[8], -41.8) else 0.0 if eq_func(algebraic[8], 0.0) else -6.80001 if eq_func(algebraic[8], -6.8) else algebraic[8] + algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0) + algebraic[73] = -1.80001 if eq_func(algebraic[8], -1.8) else algebraic[8] + algebraic[71] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0) + algebraic[69] = 0.001/(algebraic[70]+algebraic[71]) + algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[80])/(5.3+constants[81]))) + algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))) + algebraic[76] = constants[82]/(constants[82]+states[0]) + algebraic[77] = 0.001*algebraic[76]/constants[83] + algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)) + algebraic[79] = 0.001/(1.068*exp((algebraic[8]+38.3)/30.0)+1.068*exp(-(algebraic[8]+38.3)/30.0)) + algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)) + algebraic[81] = 1.0/(16.67*exp(-(algebraic[8]+75.0)/83.3)+16.67*exp((algebraic[8]+75.0)/15.38))+constants[85] + algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)) + algebraic[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[8]+44.0))+0.065*exp(0.1*(algebraic[8]+45.93)))+10.1) + algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)) + algebraic[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[8]+30.61))+0.369*exp(-0.12*(algebraic[8]+23.84)))+2.98) + algebraic[86] = 1.0/(1.0+exp(-(algebraic[8]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraic[8]/11.9)+0.96*exp(-algebraic[8]/18.5))) + algebraic[87] = 4.0*((37.2*exp(algebraic[8]/15.9)+0.96*exp(-algebraic[8]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraic[8]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraic[8]/15.9)+0.96*exp(-algebraic[8]/22.5)))) + algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)) + algebraic[89] = 0.84655354/(4.2*exp(algebraic[8]/17.0)+0.15*exp(-algebraic[8]/21.6)) + algebraic[90] = 1.0/(30.0*exp(algebraic[8]/10.0)+exp(-algebraic[8]/12.0)) + algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)) + algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)) + algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computed_constants[23])/10.7071))) + algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computed_constants[23])/3.0)) + algebraic[97] = 1.0*exp(-(algebraic[8]-computed_constants[23]-5.0)/25.0) + algebraic[95] = 1.0/(algebraic[96]+algebraic[97]) + algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)) + algebraic[99] = computed_constants[24]/(computed_constants[24]+algebraic[98]) + algebraic[100] = 1.0/(computed_constants[24]+algebraic[98]) diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 229024166..05de7d9e6 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -250,116 +250,116 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - constants[1] = 0.0; - constants[2] = 1.0; - constants[3] = 1.0309347; - constants[5] = 2.0e-5; - constants[6] = 6.5e-5; - constants[22] = 8314.0; - constants[23] = 310.0; - constants[24] = 96845.0; - constants[26] = 5.8e-5; - constants[27] = 0.000189; - constants[28] = 5.8e-5; - constants[29] = 0.000189; - constants[30] = 5.81818e-5; - constants[31] = 0.0001888; - constants[34] = 2.52e-5; - constants[35] = 8.19e-5; - constants[36] = 2.52e-5; - constants[37] = 8.19e-5; - constants[38] = 2.523636e-5; - constants[39] = 8.1892e-5; - constants[42] = 1.32e-5; - constants[43] = 4.3e-5; - constants[44] = 1.323e-5; - constants[45] = 4.29e-5; - constants[46] = 1.3236e-5; - constants[47] = 4.2952e-5; - constants[50] = 2.7e-6; - constants[51] = 8.8e-6; - constants[52] = 2.8e-6; - constants[53] = 8.8e-6; - constants[54] = 2.7229e-6; - constants[55] = 8.83584e-6; - constants[56] = 8.0; - constants[57] = 0.5; - constants[58] = 2.0; - constants[59] = 140.0; - constants[60] = 0.0001; - constants[61] = 0.0001; - constants[63] = 0.0478; - constants[64] = 0.16; - constants[65] = 0.0478; - constants[66] = 0.16; - constants[67] = 0.04782545; - constants[68] = 0.1551936; - constants[69] = 5.4; - constants[70] = 0.621; - constants[71] = 5.64; - constants[73] = 0.0; - constants[74] = 0.0; - constants[75] = 0.0042; - constants[76] = 0.03339; - constants[77] = 0.0; - constants[78] = 0.0; - constants[79] = 140.0; - constants[82] = 0.0; - constants[83] = 1.2e-6; - constants[84] = 0.0; - constants[85] = 3.7e-7; - constants[86] = 0.0; - constants[87] = 1.204e-6; - constants[97] = 0.0058; - constants[98] = 0.0659; - constants[99] = 0.0082; - constants[100] = 0.0659; - constants[101] = 0.0057938; - constants[102] = 0.06588648; - constants[103] = 46.4; - constants[113] = 0.0043; - constants[114] = 0.0139; - constants[115] = 0.0021; - constants[116] = 0.00694; - constants[117] = 0.00427806; - constants[118] = 0.0138823; - constants[119] = 45.0; - constants[129] = 0.00491; - constants[130] = 0.03649; - constants[131] = 0.004905; - constants[132] = 0.0365; - constants[133] = 0.004905; - constants[134] = 0.036495; - constants[136] = 6.65e-5; - constants[137] = 0.0114; - constants[138] = 0.000266; - constants[139] = 0.0114; - constants[140] = 6.645504e-5; - constants[141] = 0.01138376; - constants[147] = 0.000797; - constants[148] = 0.016; - constants[149] = 0.000738; - constants[150] = 0.0208; - constants[151] = 0.00079704; - constants[152] = 0.016; - constants[161] = 0.000518; - constants[162] = 0.0104; - constants[163] = 0.000345; - constants[164] = 0.0104; - constants[165] = 0.0003445; - constants[166] = 0.0104; - constants[170] = 0.000548; - constants[171] = 0.0069; - constants[172] = 0.000437; - constants[173] = 0.0055; - constants[174] = 0.0005465; - constants[175] = 0.006875; - constants[177] = 0.000548; - constants[178] = 0.0069; - constants[179] = 0.000437; - constants[180] = 0.0055; - constants[181] = 0.0005465; - constants[182] = 0.006875; + constants[0] = 0.0; + constants[1] = 1.0; + constants[2] = 1.0309347; + constants[3] = 2.0e-5; + constants[4] = 6.5e-5; + constants[5] = 8314.0; + constants[6] = 310.0; + constants[7] = 96845.0; + constants[8] = 5.8e-5; + constants[9] = 0.000189; + constants[10] = 5.8e-5; + constants[11] = 0.000189; + constants[12] = 5.81818e-5; + constants[13] = 0.0001888; + constants[14] = 2.52e-5; + constants[15] = 8.19e-5; + constants[16] = 2.52e-5; + constants[17] = 8.19e-5; + constants[18] = 2.523636e-5; + constants[19] = 8.1892e-5; + constants[20] = 1.32e-5; + constants[21] = 4.3e-5; + constants[22] = 1.323e-5; + constants[23] = 4.29e-5; + constants[24] = 1.3236e-5; + constants[25] = 4.2952e-5; + constants[26] = 2.7e-6; + constants[27] = 8.8e-6; + constants[28] = 2.8e-6; + constants[29] = 8.8e-6; + constants[30] = 2.7229e-6; + constants[31] = 8.83584e-6; + constants[32] = 8.0; + constants[33] = 0.5; + constants[34] = 2.0; + constants[35] = 140.0; + constants[36] = 0.0001; + constants[37] = 0.0001; + constants[38] = 0.0478; + constants[39] = 0.16; + constants[40] = 0.0478; + constants[41] = 0.16; + constants[42] = 0.04782545; + constants[43] = 0.1551936; + constants[44] = 5.4; + constants[45] = 0.621; + constants[46] = 5.64; + constants[47] = 0.0; + constants[48] = 0.0; + constants[49] = 0.0042; + constants[50] = 0.03339; + constants[51] = 0.0; + constants[52] = 0.0; + constants[53] = 140.0; + constants[54] = 0.0; + constants[55] = 1.2e-6; + constants[56] = 0.0; + constants[57] = 3.7e-7; + constants[58] = 0.0; + constants[59] = 1.204e-6; + constants[60] = 0.0058; + constants[61] = 0.0659; + constants[62] = 0.0082; + constants[63] = 0.0659; + constants[64] = 0.0057938; + constants[65] = 0.06588648; + constants[66] = 46.4; + constants[67] = 0.0043; + constants[68] = 0.0139; + constants[69] = 0.0021; + constants[70] = 0.00694; + constants[71] = 0.00427806; + constants[72] = 0.0138823; + constants[73] = 45.0; + constants[74] = 0.00491; + constants[75] = 0.03649; + constants[76] = 0.004905; + constants[77] = 0.0365; + constants[78] = 0.004905; + constants[79] = 0.036495; + constants[80] = 6.65e-5; + constants[81] = 0.0114; + constants[82] = 0.000266; + constants[83] = 0.0114; + constants[84] = 6.645504e-5; + constants[85] = 0.01138376; + constants[86] = 0.000797; + constants[87] = 0.016; + constants[88] = 0.000738; + constants[89] = 0.0208; + constants[90] = 0.00079704; + constants[91] = 0.016; + constants[92] = 0.000518; + constants[93] = 0.0104; + constants[94] = 0.000345; + constants[95] = 0.0104; + constants[96] = 0.0003445; + constants[97] = 0.0104; + constants[98] = 0.000548; + constants[99] = 0.0069; + constants[100] = 0.000437; + constants[101] = 0.0055; + constants[102] = 0.0005465; + constants[103] = 0.006875; + constants[104] = 0.000548; + constants[105] = 0.0069; + constants[106] = 0.000437; + constants[107] = 0.0055; + constants[108] = 0.0005465; + constants[109] = 0.006875; states[0] = -39.013558536; states[1] = 0.092361701692; states[2] = 0.015905380261; @@ -379,154 +379,154 @@ void initialiseVariables(double *states, double *rates, double *constants) void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = (constants[2] == 0.0)?1.07*(3.0*constants[1]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*constants[1]-2.05)/0.295))):(constants[2] == 1.0)?constants[3]*constants[1]/(1.0+0.7745*exp(-(3.0*constants[1]-2.05)/0.295)):1.07*29.0*constants[1]/(30.0*(1.0+0.7745*exp(-(29.0*constants[1]-24.5)/1.95))); - computedConstants[4] = constants[5]+computedConstants[0]*(constants[6]-constants[5]); - computedConstants[25] = (constants[2] == 0.0)?constants[26]+computedConstants[0]*(constants[27]-constants[26]):(constants[2] == 1.0)?constants[30]+computedConstants[0]*(constants[31]-constants[30]):constants[28]+computedConstants[0]*(constants[29]-constants[28]); - computedConstants[33] = (constants[2] == 0.0)?constants[34]+computedConstants[0]*(constants[35]-constants[34]):(constants[2] == 1.0)?constants[38]+computedConstants[0]*(constants[39]-constants[38]):constants[36]+computedConstants[0]*(constants[37]-constants[36]); - computedConstants[41] = (constants[2] == 0.0)?constants[42]+computedConstants[0]*(constants[43]-constants[42]):(constants[2] == 1.0)?constants[46]+computedConstants[0]*(constants[47]-constants[46]):constants[44]+computedConstants[0]*(constants[45]-constants[44]); - computedConstants[49] = (constants[2] == 0.0)?constants[50]+computedConstants[0]*(constants[51]-constants[50]):(constants[2] == 1.0)?constants[54]+computedConstants[0]*(constants[55]-constants[54]):constants[52]+computedConstants[0]*(constants[53]-constants[52]); - computedConstants[62] = (constants[2] == 0.0)?constants[63]+computedConstants[0]*(constants[64]-constants[63]):(constants[2] == 1.0)?constants[67]+computedConstants[0]*(constants[68]-constants[67]):constants[65]+computedConstants[0]*(constants[66]-constants[65]); - computedConstants[72] = (constants[2] == 0.0)?constants[73]+computedConstants[0]*(constants[74]-constants[73]):(constants[2] == 1.0)?constants[77]+computedConstants[0]*(constants[78]-constants[77]):constants[75]+computedConstants[0]*(constants[76]-constants[75]); - computedConstants[8] = computedConstants[72]*constants[60]/(constants[60]+0.0004); - computedConstants[32] = constants[22]*constants[23]/constants[24]*log(constants[59]/constants[56]); - computedConstants[40] = constants[22]*constants[23]/constants[24]*log(constants[69]/constants[79]); - computedConstants[48] = constants[22]*constants[23]/(2.0*constants[24])*log(constants[58]/constants[60]); - computedConstants[80] = (constants[2] == 0.0)?constants[22]*constants[23]/constants[24]*log((constants[69]+0.12*constants[59])/(constants[79]+0.12*constants[56])):constants[22]*constants[23]/constants[24]*log((constants[69]+0.03*constants[59])/(constants[79]+0.03*constants[56])); - computedConstants[81] = (constants[2] == 0.0)?constants[82]+computedConstants[0]*(constants[83]-constants[82]):(constants[2] == 1.0)?constants[86]+computedConstants[0]*(constants[87]-constants[86]):constants[84]+computedConstants[0]*(constants[85]-constants[84]); - computedConstants[96] = (constants[2] == 0.0)?constants[97]+computedConstants[0]*(constants[98]-constants[97]):(constants[2] == 1.0)?constants[101]+computedConstants[0]*(constants[102]-constants[101]):constants[99]+computedConstants[0]*(constants[100]-constants[99]); - computedConstants[112] = (constants[2] == 0.0)?constants[113]+computedConstants[0]*(constants[114]-constants[113]):(constants[2] == 1.0)?constants[117]+computedConstants[0]*(constants[118]-constants[117]):constants[115]+computedConstants[0]*(constants[116]-constants[115]); - computedConstants[128] = (constants[2] == 0.0)?constants[129]+computedConstants[0]*(constants[130]-constants[129]):(constants[2] == 1.0)?constants[133]+computedConstants[0]*(constants[134]-constants[133]):constants[131]+computedConstants[0]*(constants[132]-constants[131]); - computedConstants[135] = (constants[2] == 0.0)?constants[136]+computedConstants[0]*(constants[137]-constants[136]):(constants[2] == 1.0)?constants[140]+computedConstants[0]*(constants[141]-constants[140]):constants[138]+computedConstants[0]*(constants[139]-constants[138]); - computedConstants[146] = (constants[2] == 0.0)?constants[147]+computedConstants[0]*(constants[148]-constants[147]):(constants[2] == 1.0)?constants[151]+computedConstants[0]*(constants[152]-constants[151]):constants[149]+computedConstants[0]*(constants[150]-constants[149]); - computedConstants[158] = (constants[2] == 0.0)?0.002:(constants[2] == 1.0)?0.002:0.006; - computedConstants[160] = (constants[2] == 0.0)?constants[161]+computedConstants[0]*(constants[162]-constants[161]):(constants[2] == 1.0)?constants[165]+computedConstants[0]*(constants[166]-constants[165]):constants[163]+computedConstants[0]*(constants[164]-constants[163]); - computedConstants[169] = (constants[2] == 0.0)?constants[170]+computedConstants[0]*(constants[171]-constants[170]):(constants[2] == 1.0)?constants[174]+computedConstants[0]*(constants[175]-constants[174]):constants[172]+computedConstants[0]*(constants[173]-constants[172]); - computedConstants[176] = (constants[2] == 0.0)?constants[177]+computedConstants[0]*(constants[178]-constants[177]):(constants[2] == 1.0)?constants[181]+computedConstants[0]*(constants[182]-constants[181]):constants[179]+computedConstants[0]*(constants[180]-constants[179]); + computedConstants[0] = (constants[1] == 0.0)?1.07*(3.0*constants[0]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*constants[0]-2.05)/0.295))):(constants[1] == 1.0)?constants[2]*constants[0]/(1.0+0.7745*exp(-(3.0*constants[0]-2.05)/0.295)):1.07*29.0*constants[0]/(30.0*(1.0+0.7745*exp(-(29.0*constants[0]-24.5)/1.95))); + computedConstants[1] = constants[3]+computedConstants[0]*(constants[4]-constants[3]); + computedConstants[3] = (constants[1] == 0.0)?constants[8]+computedConstants[0]*(constants[9]-constants[8]):(constants[1] == 1.0)?constants[12]+computedConstants[0]*(constants[13]-constants[12]):constants[10]+computedConstants[0]*(constants[11]-constants[10]); + computedConstants[5] = (constants[1] == 0.0)?constants[14]+computedConstants[0]*(constants[15]-constants[14]):(constants[1] == 1.0)?constants[18]+computedConstants[0]*(constants[19]-constants[18]):constants[16]+computedConstants[0]*(constants[17]-constants[16]); + computedConstants[7] = (constants[1] == 0.0)?constants[20]+computedConstants[0]*(constants[21]-constants[20]):(constants[1] == 1.0)?constants[24]+computedConstants[0]*(constants[25]-constants[24]):constants[22]+computedConstants[0]*(constants[23]-constants[22]); + computedConstants[9] = (constants[1] == 0.0)?constants[26]+computedConstants[0]*(constants[27]-constants[26]):(constants[1] == 1.0)?constants[30]+computedConstants[0]*(constants[31]-constants[30]):constants[28]+computedConstants[0]*(constants[29]-constants[28]); + computedConstants[10] = (constants[1] == 0.0)?constants[38]+computedConstants[0]*(constants[39]-constants[38]):(constants[1] == 1.0)?constants[42]+computedConstants[0]*(constants[43]-constants[42]):constants[40]+computedConstants[0]*(constants[41]-constants[40]); + computedConstants[11] = (constants[1] == 0.0)?constants[47]+computedConstants[0]*(constants[48]-constants[47]):(constants[1] == 1.0)?constants[51]+computedConstants[0]*(constants[52]-constants[51]):constants[49]+computedConstants[0]*(constants[50]-constants[49]); + computedConstants[2] = computedConstants[11]*constants[36]/(constants[36]+0.0004); + computedConstants[4] = constants[5]*constants[6]/constants[7]*log(constants[35]/constants[32]); + computedConstants[6] = constants[5]*constants[6]/constants[7]*log(constants[44]/constants[53]); + computedConstants[8] = constants[5]*constants[6]/(2.0*constants[7])*log(constants[34]/constants[36]); + computedConstants[12] = (constants[1] == 0.0)?constants[5]*constants[6]/constants[7]*log((constants[44]+0.12*constants[35])/(constants[53]+0.12*constants[32])):constants[5]*constants[6]/constants[7]*log((constants[44]+0.03*constants[35])/(constants[53]+0.03*constants[32])); + computedConstants[13] = (constants[1] == 0.0)?constants[54]+computedConstants[0]*(constants[55]-constants[54]):(constants[1] == 1.0)?constants[58]+computedConstants[0]*(constants[59]-constants[58]):constants[56]+computedConstants[0]*(constants[57]-constants[56]); + computedConstants[14] = (constants[1] == 0.0)?constants[60]+computedConstants[0]*(constants[61]-constants[60]):(constants[1] == 1.0)?constants[64]+computedConstants[0]*(constants[65]-constants[64]):constants[62]+computedConstants[0]*(constants[63]-constants[62]); + computedConstants[15] = (constants[1] == 0.0)?constants[67]+computedConstants[0]*(constants[68]-constants[67]):(constants[1] == 1.0)?constants[71]+computedConstants[0]*(constants[72]-constants[71]):constants[69]+computedConstants[0]*(constants[70]-constants[69]); + computedConstants[16] = (constants[1] == 0.0)?constants[74]+computedConstants[0]*(constants[75]-constants[74]):(constants[1] == 1.0)?constants[78]+computedConstants[0]*(constants[79]-constants[78]):constants[76]+computedConstants[0]*(constants[77]-constants[76]); + computedConstants[17] = (constants[1] == 0.0)?constants[80]+computedConstants[0]*(constants[81]-constants[80]):(constants[1] == 1.0)?constants[84]+computedConstants[0]*(constants[85]-constants[84]):constants[82]+computedConstants[0]*(constants[83]-constants[82]); + computedConstants[18] = (constants[1] == 0.0)?constants[86]+computedConstants[0]*(constants[87]-constants[86]):(constants[1] == 1.0)?constants[90]+computedConstants[0]*(constants[91]-constants[90]):constants[88]+computedConstants[0]*(constants[89]-constants[88]); + computedConstants[19] = (constants[1] == 0.0)?0.002:(constants[1] == 1.0)?0.002:0.006; + computedConstants[20] = (constants[1] == 0.0)?constants[92]+computedConstants[0]*(constants[93]-constants[92]):(constants[1] == 1.0)?constants[96]+computedConstants[0]*(constants[97]-constants[96]):constants[94]+computedConstants[0]*(constants[95]-constants[94]); + computedConstants[21] = (constants[1] == 0.0)?constants[98]+computedConstants[0]*(constants[99]-constants[98]):(constants[1] == 1.0)?constants[102]+computedConstants[0]*(constants[103]-constants[102]):constants[100]+computedConstants[0]*(constants[101]-constants[100]); + computedConstants[22] = (constants[1] == 0.0)?constants[104]+computedConstants[0]*(constants[105]-constants[104]):(constants[1] == 1.0)?constants[108]+computedConstants[0]*(constants[109]-constants[108]):constants[106]+computedConstants[0]*(constants[107]-constants[106]); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[9] = computedConstants[62]*pow(constants[56]/(constants[71]+constants[56]), 3.0)*pow(constants[69]/(constants[70]+constants[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); - algebraic[10] = (constants[2] == 0.0)?computedConstants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.0374*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))):computedConstants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.03743*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))); - algebraic[14] = (constants[2] != 2.0)?computedConstants[176]*states[14]*(states[0]-computedConstants[40]):computedConstants[176]*states[14]*(states[0]+102.0); - algebraic[15] = (constants[2] != 2.0)?computedConstants[169]*states[14]*(states[0]-computedConstants[32]):computedConstants[169]*states[14]*(states[0]-77.6); - algebraic[16] = computedConstants[160]*pow(states[13], 2.0)*(states[0]-computedConstants[80]); - algebraic[18] = computedConstants[135]*states[8]*(states[0]-computedConstants[40]); - algebraic[19] = computedConstants[128]*states[9]*states[8]*(states[0]-computedConstants[40]); - algebraic[20] = computedConstants[112]*states[7]*states[6]*(states[0]-constants[119]); - algebraic[21] = computedConstants[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[103]); - algebraic[91] = (constants[2] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; - algebraic[88] = (1.0-algebraic[91])*states[2]+algebraic[91]*states[3]; - algebraic[7] = computedConstants[81]*pow(states[1], 3.0)*algebraic[88]*constants[59]*pow(constants[24], 2.0)/(constants[22]*constants[23])*(exp((states[0]-computedConstants[32])*constants[24]/(constants[22]*constants[23]))-1.0)/(exp(states[0]*constants[24]/(constants[22]*constants[23]))-1.0)*states[0]; - algebraic[11] = computedConstants[33]*(states[0]-computedConstants[40]); - algebraic[12] = computedConstants[41]*(states[0]-computedConstants[48]); - algebraic[13] = computedConstants[25]*(states[0]-computedConstants[32]); - algebraic[153] = 0.6*states[11]+0.4*states[12]; - algebraic[17] = computedConstants[146]*algebraic[153]*states[10]*(states[0]-computedConstants[40]); - rates[0] = -1.0/computedConstants[4]*(algebraic[7]+algebraic[21]+algebraic[20]+algebraic[19]+algebraic[18]+algebraic[17]+algebraic[16]+algebraic[15]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+computedConstants[8]); - algebraic[89] = (constants[2] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); - algebraic[90] = (constants[2] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; - rates[1] = (algebraic[89]-states[1])/algebraic[90]; - algebraic[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); - algebraic[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; - rates[2] = (algebraic[92]-states[2])/algebraic[93]; - algebraic[94] = algebraic[92]; - algebraic[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; - rates[3] = (algebraic[94]-states[3])/algebraic[95]; - algebraic[104] = (constants[2] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[2] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); - algebraic[106] = (constants[2] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[2] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); - algebraic[107] = (constants[2] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); - algebraic[105] = 2.0/(algebraic[106]+algebraic[107]); - rates[5] = (algebraic[104]-states[5])/algebraic[105]; - algebraic[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); - algebraic[110] = (constants[2] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); - algebraic[111] = (constants[2] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); - algebraic[109] = (constants[2] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[110]+algebraic[111]):1.0/(algebraic[110]+algebraic[111]); - rates[4] = (algebraic[108]-states[4])/algebraic[109]; - algebraic[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); - algebraic[122] = 1068.0*exp((states[0]+26.3)/30.0); - algebraic[123] = 1068.0*exp(-(states[0]+26.3)/30.0); - algebraic[121] = 1.0/(algebraic[122]+algebraic[123]); - rates[7] = (algebraic[120]-states[7])/algebraic[121]; - algebraic[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); - algebraic[126] = (constants[2] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); - algebraic[127] = (constants[2] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); - algebraic[125] = 1.0/(algebraic[126]+algebraic[127]); - rates[6] = (algebraic[124]-states[6])/algebraic[125]; - algebraic[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); - algebraic[143] = (constants[2] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[2] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); - rates[9] = (algebraic[142]-states[9])/algebraic[143]; - algebraic[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); - algebraic[145] = (constants[2] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[2] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); - rates[8] = (algebraic[144]-states[8])/algebraic[145]; - algebraic[154] = (constants[2] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); - algebraic[155] = (constants[2] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); - rates[11] = (algebraic[154]-states[11])/algebraic[155]; - algebraic[156] = algebraic[154]; - algebraic[157] = (constants[2] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); - rates[12] = (algebraic[156]-states[12])/algebraic[157]; - algebraic[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); - rates[10] = (algebraic[159]-states[10])/computedConstants[158]; - algebraic[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); - algebraic[168] = 1.0*exp(-states[0]/45.0); - rates[13] = algebraic[167]*(1.0-states[13])-algebraic[168]*states[13]; - algebraic[183] = (constants[2] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); - algebraic[184] = 1.0*exp((states[0]+75.13)/21.25); - rates[14] = algebraic[183]*(1.0-states[14])-algebraic[184]*states[14]; + algebraic[1] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); + algebraic[2] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.0374*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.03743*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))); + algebraic[6] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); + algebraic[7] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); + algebraic[8] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); + algebraic[10] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); + algebraic[11] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); + algebraic[12] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); + algebraic[13] = computedConstants[14]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); + algebraic[17] = (constants[1] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; + algebraic[14] = (1.0-algebraic[17])*states[2]+algebraic[17]*states[3]; + algebraic[0] = computedConstants[13]*pow(states[1], 3.0)*algebraic[14]*constants[35]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; + algebraic[3] = computedConstants[5]*(states[0]-computedConstants[6]); + algebraic[4] = computedConstants[7]*(states[0]-computedConstants[8]); + algebraic[5] = computedConstants[3]*(states[0]-computedConstants[4]); + algebraic[42] = 0.6*states[11]+0.4*states[12]; + algebraic[9] = computedConstants[18]*algebraic[42]*states[10]*(states[0]-computedConstants[6]); + rates[0] = -1.0/computedConstants[1]*(algebraic[0]+algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+algebraic[8]+algebraic[7]+algebraic[6]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[2]+algebraic[1]+computedConstants[2]); + algebraic[15] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); + algebraic[16] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; + rates[1] = (algebraic[15]-states[1])/algebraic[16]; + algebraic[18] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); + algebraic[19] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; + rates[2] = (algebraic[18]-states[2])/algebraic[19]; + algebraic[20] = algebraic[18]; + algebraic[21] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; + rates[3] = (algebraic[20]-states[3])/algebraic[21]; + algebraic[22] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); + algebraic[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); + algebraic[25] = (constants[1] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); + algebraic[23] = 2.0/(algebraic[24]+algebraic[25]); + rates[5] = (algebraic[22]-states[5])/algebraic[23]; + algebraic[26] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); + algebraic[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); + algebraic[29] = (constants[1] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); + algebraic[27] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[28]+algebraic[29]):1.0/(algebraic[28]+algebraic[29]); + rates[4] = (algebraic[26]-states[4])/algebraic[27]; + algebraic[30] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); + algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0); + algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0); + algebraic[31] = 1.0/(algebraic[32]+algebraic[33]); + rates[7] = (algebraic[30]-states[7])/algebraic[31]; + algebraic[34] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); + algebraic[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); + algebraic[37] = (constants[1] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); + algebraic[35] = 1.0/(algebraic[36]+algebraic[37]); + rates[6] = (algebraic[34]-states[6])/algebraic[35]; + algebraic[38] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); + algebraic[39] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); + rates[9] = (algebraic[38]-states[9])/algebraic[39]; + algebraic[40] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); + algebraic[41] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); + rates[8] = (algebraic[40]-states[8])/algebraic[41]; + algebraic[43] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); + algebraic[44] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); + rates[11] = (algebraic[43]-states[11])/algebraic[44]; + algebraic[45] = algebraic[43]; + algebraic[46] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); + rates[12] = (algebraic[45]-states[12])/algebraic[46]; + algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); + rates[10] = (algebraic[47]-states[10])/computedConstants[19]; + algebraic[48] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); + algebraic[49] = 1.0*exp(-states[0]/45.0); + rates[13] = algebraic[48]*(1.0-states[13])-algebraic[49]*states[13]; + algebraic[50] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); + algebraic[51] = 1.0*exp((states[0]+75.13)/21.25); + rates[14] = algebraic[50]*(1.0-states[14])-algebraic[51]*states[14]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[13] = computedConstants[25]*(states[0]-computedConstants[32]); - algebraic[11] = computedConstants[33]*(states[0]-computedConstants[40]); - algebraic[12] = computedConstants[41]*(states[0]-computedConstants[48]); - algebraic[10] = (constants[2] == 0.0)?computedConstants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.0374*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))):computedConstants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.03743*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))); - algebraic[9] = computedConstants[62]*pow(constants[56]/(constants[71]+constants[56]), 3.0)*pow(constants[69]/(constants[70]+constants[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); - algebraic[91] = (constants[2] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; - algebraic[88] = (1.0-algebraic[91])*states[2]+algebraic[91]*states[3]; - algebraic[7] = computedConstants[81]*pow(states[1], 3.0)*algebraic[88]*constants[59]*pow(constants[24], 2.0)/(constants[22]*constants[23])*(exp((states[0]-computedConstants[32])*constants[24]/(constants[22]*constants[23]))-1.0)/(exp(states[0]*constants[24]/(constants[22]*constants[23]))-1.0)*states[0]; - algebraic[89] = (constants[2] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); - algebraic[90] = (constants[2] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; - algebraic[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); - algebraic[94] = algebraic[92]; - algebraic[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; - algebraic[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; - algebraic[21] = computedConstants[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[103]); - algebraic[106] = (constants[2] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[2] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); - algebraic[107] = (constants[2] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); - algebraic[105] = 2.0/(algebraic[106]+algebraic[107]); - algebraic[104] = (constants[2] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[2] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); - algebraic[110] = (constants[2] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); - algebraic[111] = (constants[2] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); - algebraic[109] = (constants[2] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[110]+algebraic[111]):1.0/(algebraic[110]+algebraic[111]); - algebraic[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); - algebraic[20] = computedConstants[112]*states[7]*states[6]*(states[0]-constants[119]); - algebraic[122] = 1068.0*exp((states[0]+26.3)/30.0); - algebraic[123] = 1068.0*exp(-(states[0]+26.3)/30.0); - algebraic[121] = 1.0/(algebraic[122]+algebraic[123]); - algebraic[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); - algebraic[126] = (constants[2] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); - algebraic[127] = (constants[2] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); - algebraic[125] = 1.0/(algebraic[126]+algebraic[127]); - algebraic[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); - algebraic[19] = computedConstants[128]*states[9]*states[8]*(states[0]-computedConstants[40]); - algebraic[18] = computedConstants[135]*states[8]*(states[0]-computedConstants[40]); - algebraic[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); - algebraic[143] = (constants[2] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[2] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); - algebraic[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); - algebraic[145] = (constants[2] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[2] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); - algebraic[153] = 0.6*states[11]+0.4*states[12]; - algebraic[17] = computedConstants[146]*algebraic[153]*states[10]*(states[0]-computedConstants[40]); - algebraic[154] = (constants[2] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); - algebraic[155] = (constants[2] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); - algebraic[156] = algebraic[154]; - algebraic[157] = (constants[2] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); - algebraic[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); - algebraic[16] = computedConstants[160]*pow(states[13], 2.0)*(states[0]-computedConstants[80]); - algebraic[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); - algebraic[168] = 1.0*exp(-states[0]/45.0); - algebraic[15] = (constants[2] != 2.0)?computedConstants[169]*states[14]*(states[0]-computedConstants[32]):computedConstants[169]*states[14]*(states[0]-77.6); - algebraic[14] = (constants[2] != 2.0)?computedConstants[176]*states[14]*(states[0]-computedConstants[40]):computedConstants[176]*states[14]*(states[0]+102.0); - algebraic[183] = (constants[2] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); - algebraic[184] = 1.0*exp((states[0]+75.13)/21.25); + algebraic[5] = computedConstants[3]*(states[0]-computedConstants[4]); + algebraic[3] = computedConstants[5]*(states[0]-computedConstants[6]); + algebraic[4] = computedConstants[7]*(states[0]-computedConstants[8]); + algebraic[2] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.0374*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.03743*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))); + algebraic[1] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); + algebraic[17] = (constants[1] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; + algebraic[14] = (1.0-algebraic[17])*states[2]+algebraic[17]*states[3]; + algebraic[0] = computedConstants[13]*pow(states[1], 3.0)*algebraic[14]*constants[35]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; + algebraic[15] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); + algebraic[16] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; + algebraic[18] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); + algebraic[20] = algebraic[18]; + algebraic[19] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; + algebraic[21] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; + algebraic[13] = computedConstants[14]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); + algebraic[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); + algebraic[25] = (constants[1] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); + algebraic[23] = 2.0/(algebraic[24]+algebraic[25]); + algebraic[22] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); + algebraic[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); + algebraic[29] = (constants[1] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); + algebraic[27] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[28]+algebraic[29]):1.0/(algebraic[28]+algebraic[29]); + algebraic[26] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); + algebraic[12] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); + algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0); + algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0); + algebraic[31] = 1.0/(algebraic[32]+algebraic[33]); + algebraic[30] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); + algebraic[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); + algebraic[37] = (constants[1] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); + algebraic[35] = 1.0/(algebraic[36]+algebraic[37]); + algebraic[34] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); + algebraic[11] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); + algebraic[10] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); + algebraic[38] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); + algebraic[39] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); + algebraic[40] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); + algebraic[41] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); + algebraic[42] = 0.6*states[11]+0.4*states[12]; + algebraic[9] = computedConstants[18]*algebraic[42]*states[10]*(states[0]-computedConstants[6]); + algebraic[43] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); + algebraic[44] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); + algebraic[45] = algebraic[43]; + algebraic[46] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); + algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); + algebraic[8] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); + algebraic[48] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); + algebraic[49] = 1.0*exp(-states[0]/45.0); + algebraic[7] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); + algebraic[6] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); + algebraic[50] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); + algebraic[51] = 1.0*exp((states[0]+75.13)/21.25); } diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 241a885d1..b07aec10e 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -247,116 +247,116 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - constants[1] = 0.0 - constants[2] = 1.0 - constants[3] = 1.0309347 - constants[5] = 2.0e-5 - constants[6] = 6.5e-5 - constants[22] = 8314.0 - constants[23] = 310.0 - constants[24] = 96845.0 - constants[26] = 5.8e-5 - constants[27] = 0.000189 - constants[28] = 5.8e-5 - constants[29] = 0.000189 - constants[30] = 5.81818e-5 - constants[31] = 0.0001888 - constants[34] = 2.52e-5 - constants[35] = 8.19e-5 - constants[36] = 2.52e-5 - constants[37] = 8.19e-5 - constants[38] = 2.523636e-5 - constants[39] = 8.1892e-5 - constants[42] = 1.32e-5 - constants[43] = 4.3e-5 - constants[44] = 1.323e-5 - constants[45] = 4.29e-5 - constants[46] = 1.3236e-5 - constants[47] = 4.2952e-5 - constants[50] = 2.7e-6 - constants[51] = 8.8e-6 - constants[52] = 2.8e-6 - constants[53] = 8.8e-6 - constants[54] = 2.7229e-6 - constants[55] = 8.83584e-6 - constants[56] = 8.0 - constants[57] = 0.5 - constants[58] = 2.0 - constants[59] = 140.0 - constants[60] = 0.0001 - constants[61] = 0.0001 - constants[63] = 0.0478 - constants[64] = 0.16 - constants[65] = 0.0478 - constants[66] = 0.16 - constants[67] = 0.04782545 - constants[68] = 0.1551936 - constants[69] = 5.4 - constants[70] = 0.621 - constants[71] = 5.64 - constants[73] = 0.0 - constants[74] = 0.0 - constants[75] = 0.0042 - constants[76] = 0.03339 - constants[77] = 0.0 - constants[78] = 0.0 - constants[79] = 140.0 - constants[82] = 0.0 - constants[83] = 1.2e-6 - constants[84] = 0.0 - constants[85] = 3.7e-7 - constants[86] = 0.0 - constants[87] = 1.204e-6 - constants[97] = 0.0058 - constants[98] = 0.0659 - constants[99] = 0.0082 - constants[100] = 0.0659 - constants[101] = 0.0057938 - constants[102] = 0.06588648 - constants[103] = 46.4 - constants[113] = 0.0043 - constants[114] = 0.0139 - constants[115] = 0.0021 - constants[116] = 0.00694 - constants[117] = 0.00427806 - constants[118] = 0.0138823 - constants[119] = 45.0 - constants[129] = 0.00491 - constants[130] = 0.03649 - constants[131] = 0.004905 - constants[132] = 0.0365 - constants[133] = 0.004905 - constants[134] = 0.036495 - constants[136] = 6.65e-5 - constants[137] = 0.0114 - constants[138] = 0.000266 - constants[139] = 0.0114 - constants[140] = 6.645504e-5 - constants[141] = 0.01138376 - constants[147] = 0.000797 - constants[148] = 0.016 - constants[149] = 0.000738 - constants[150] = 0.0208 - constants[151] = 0.00079704 - constants[152] = 0.016 - constants[161] = 0.000518 - constants[162] = 0.0104 - constants[163] = 0.000345 - constants[164] = 0.0104 - constants[165] = 0.0003445 - constants[166] = 0.0104 - constants[170] = 0.000548 - constants[171] = 0.0069 - constants[172] = 0.000437 - constants[173] = 0.0055 - constants[174] = 0.0005465 - constants[175] = 0.006875 - constants[177] = 0.000548 - constants[178] = 0.0069 - constants[179] = 0.000437 - constants[180] = 0.0055 - constants[181] = 0.0005465 - constants[182] = 0.006875 + constants[0] = 0.0 + constants[1] = 1.0 + constants[2] = 1.0309347 + constants[3] = 2.0e-5 + constants[4] = 6.5e-5 + constants[5] = 8314.0 + constants[6] = 310.0 + constants[7] = 96845.0 + constants[8] = 5.8e-5 + constants[9] = 0.000189 + constants[10] = 5.8e-5 + constants[11] = 0.000189 + constants[12] = 5.81818e-5 + constants[13] = 0.0001888 + constants[14] = 2.52e-5 + constants[15] = 8.19e-5 + constants[16] = 2.52e-5 + constants[17] = 8.19e-5 + constants[18] = 2.523636e-5 + constants[19] = 8.1892e-5 + constants[20] = 1.32e-5 + constants[21] = 4.3e-5 + constants[22] = 1.323e-5 + constants[23] = 4.29e-5 + constants[24] = 1.3236e-5 + constants[25] = 4.2952e-5 + constants[26] = 2.7e-6 + constants[27] = 8.8e-6 + constants[28] = 2.8e-6 + constants[29] = 8.8e-6 + constants[30] = 2.7229e-6 + constants[31] = 8.83584e-6 + constants[32] = 8.0 + constants[33] = 0.5 + constants[34] = 2.0 + constants[35] = 140.0 + constants[36] = 0.0001 + constants[37] = 0.0001 + constants[38] = 0.0478 + constants[39] = 0.16 + constants[40] = 0.0478 + constants[41] = 0.16 + constants[42] = 0.04782545 + constants[43] = 0.1551936 + constants[44] = 5.4 + constants[45] = 0.621 + constants[46] = 5.64 + constants[47] = 0.0 + constants[48] = 0.0 + constants[49] = 0.0042 + constants[50] = 0.03339 + constants[51] = 0.0 + constants[52] = 0.0 + constants[53] = 140.0 + constants[54] = 0.0 + constants[55] = 1.2e-6 + constants[56] = 0.0 + constants[57] = 3.7e-7 + constants[58] = 0.0 + constants[59] = 1.204e-6 + constants[60] = 0.0058 + constants[61] = 0.0659 + constants[62] = 0.0082 + constants[63] = 0.0659 + constants[64] = 0.0057938 + constants[65] = 0.06588648 + constants[66] = 46.4 + constants[67] = 0.0043 + constants[68] = 0.0139 + constants[69] = 0.0021 + constants[70] = 0.00694 + constants[71] = 0.00427806 + constants[72] = 0.0138823 + constants[73] = 45.0 + constants[74] = 0.00491 + constants[75] = 0.03649 + constants[76] = 0.004905 + constants[77] = 0.0365 + constants[78] = 0.004905 + constants[79] = 0.036495 + constants[80] = 6.65e-5 + constants[81] = 0.0114 + constants[82] = 0.000266 + constants[83] = 0.0114 + constants[84] = 6.645504e-5 + constants[85] = 0.01138376 + constants[86] = 0.000797 + constants[87] = 0.016 + constants[88] = 0.000738 + constants[89] = 0.0208 + constants[90] = 0.00079704 + constants[91] = 0.016 + constants[92] = 0.000518 + constants[93] = 0.0104 + constants[94] = 0.000345 + constants[95] = 0.0104 + constants[96] = 0.0003445 + constants[97] = 0.0104 + constants[98] = 0.000548 + constants[99] = 0.0069 + constants[100] = 0.000437 + constants[101] = 0.0055 + constants[102] = 0.0005465 + constants[103] = 0.006875 + constants[104] = 0.000548 + constants[105] = 0.0069 + constants[106] = 0.000437 + constants[107] = 0.0055 + constants[108] = 0.0005465 + constants[109] = 0.006875 states[0] = -39.013558536 states[1] = 0.092361701692 states[2] = 0.015905380261 @@ -375,151 +375,151 @@ def initialise_variables(states, rates, constants): def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 1.07*(3.0*constants[1]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*constants[1]-2.05)/0.295))) if eq_func(constants[2], 0.0) else constants[3]*constants[1]/(1.0+0.7745*exp(-(3.0*constants[1]-2.05)/0.295)) if eq_func(constants[2], 1.0) else 1.07*29.0*constants[1]/(30.0*(1.0+0.7745*exp(-(29.0*constants[1]-24.5)/1.95))) - computed_constants[4] = constants[5]+computed_constants[0]*(constants[6]-constants[5]) - computed_constants[25] = constants[26]+computed_constants[0]*(constants[27]-constants[26]) if eq_func(constants[2], 0.0) else constants[30]+computed_constants[0]*(constants[31]-constants[30]) if eq_func(constants[2], 1.0) else constants[28]+computed_constants[0]*(constants[29]-constants[28]) - computed_constants[33] = constants[34]+computed_constants[0]*(constants[35]-constants[34]) if eq_func(constants[2], 0.0) else constants[38]+computed_constants[0]*(constants[39]-constants[38]) if eq_func(constants[2], 1.0) else constants[36]+computed_constants[0]*(constants[37]-constants[36]) - computed_constants[41] = constants[42]+computed_constants[0]*(constants[43]-constants[42]) if eq_func(constants[2], 0.0) else constants[46]+computed_constants[0]*(constants[47]-constants[46]) if eq_func(constants[2], 1.0) else constants[44]+computed_constants[0]*(constants[45]-constants[44]) - computed_constants[49] = constants[50]+computed_constants[0]*(constants[51]-constants[50]) if eq_func(constants[2], 0.0) else constants[54]+computed_constants[0]*(constants[55]-constants[54]) if eq_func(constants[2], 1.0) else constants[52]+computed_constants[0]*(constants[53]-constants[52]) - computed_constants[62] = constants[63]+computed_constants[0]*(constants[64]-constants[63]) if eq_func(constants[2], 0.0) else constants[67]+computed_constants[0]*(constants[68]-constants[67]) if eq_func(constants[2], 1.0) else constants[65]+computed_constants[0]*(constants[66]-constants[65]) - computed_constants[72] = constants[73]+computed_constants[0]*(constants[74]-constants[73]) if eq_func(constants[2], 0.0) else constants[77]+computed_constants[0]*(constants[78]-constants[77]) if eq_func(constants[2], 1.0) else constants[75]+computed_constants[0]*(constants[76]-constants[75]) - computed_constants[8] = computed_constants[72]*constants[60]/(constants[60]+0.0004) - computed_constants[32] = constants[22]*constants[23]/constants[24]*log(constants[59]/constants[56]) - computed_constants[40] = constants[22]*constants[23]/constants[24]*log(constants[69]/constants[79]) - computed_constants[48] = constants[22]*constants[23]/(2.0*constants[24])*log(constants[58]/constants[60]) - computed_constants[80] = constants[22]*constants[23]/constants[24]*log((constants[69]+0.12*constants[59])/(constants[79]+0.12*constants[56])) if eq_func(constants[2], 0.0) else constants[22]*constants[23]/constants[24]*log((constants[69]+0.03*constants[59])/(constants[79]+0.03*constants[56])) - computed_constants[81] = constants[82]+computed_constants[0]*(constants[83]-constants[82]) if eq_func(constants[2], 0.0) else constants[86]+computed_constants[0]*(constants[87]-constants[86]) if eq_func(constants[2], 1.0) else constants[84]+computed_constants[0]*(constants[85]-constants[84]) - computed_constants[96] = constants[97]+computed_constants[0]*(constants[98]-constants[97]) if eq_func(constants[2], 0.0) else constants[101]+computed_constants[0]*(constants[102]-constants[101]) if eq_func(constants[2], 1.0) else constants[99]+computed_constants[0]*(constants[100]-constants[99]) - computed_constants[112] = constants[113]+computed_constants[0]*(constants[114]-constants[113]) if eq_func(constants[2], 0.0) else constants[117]+computed_constants[0]*(constants[118]-constants[117]) if eq_func(constants[2], 1.0) else constants[115]+computed_constants[0]*(constants[116]-constants[115]) - computed_constants[128] = constants[129]+computed_constants[0]*(constants[130]-constants[129]) if eq_func(constants[2], 0.0) else constants[133]+computed_constants[0]*(constants[134]-constants[133]) if eq_func(constants[2], 1.0) else constants[131]+computed_constants[0]*(constants[132]-constants[131]) - computed_constants[135] = constants[136]+computed_constants[0]*(constants[137]-constants[136]) if eq_func(constants[2], 0.0) else constants[140]+computed_constants[0]*(constants[141]-constants[140]) if eq_func(constants[2], 1.0) else constants[138]+computed_constants[0]*(constants[139]-constants[138]) - computed_constants[146] = constants[147]+computed_constants[0]*(constants[148]-constants[147]) if eq_func(constants[2], 0.0) else constants[151]+computed_constants[0]*(constants[152]-constants[151]) if eq_func(constants[2], 1.0) else constants[149]+computed_constants[0]*(constants[150]-constants[149]) - computed_constants[158] = 0.002 if eq_func(constants[2], 0.0) else 0.002 if eq_func(constants[2], 1.0) else 0.006 - computed_constants[160] = constants[161]+computed_constants[0]*(constants[162]-constants[161]) if eq_func(constants[2], 0.0) else constants[165]+computed_constants[0]*(constants[166]-constants[165]) if eq_func(constants[2], 1.0) else constants[163]+computed_constants[0]*(constants[164]-constants[163]) - computed_constants[169] = constants[170]+computed_constants[0]*(constants[171]-constants[170]) if eq_func(constants[2], 0.0) else constants[174]+computed_constants[0]*(constants[175]-constants[174]) if eq_func(constants[2], 1.0) else constants[172]+computed_constants[0]*(constants[173]-constants[172]) - computed_constants[176] = constants[177]+computed_constants[0]*(constants[178]-constants[177]) if eq_func(constants[2], 0.0) else constants[181]+computed_constants[0]*(constants[182]-constants[181]) if eq_func(constants[2], 1.0) else constants[179]+computed_constants[0]*(constants[180]-constants[179]) + computed_constants[0] = 1.07*(3.0*constants[0]-0.1)/(3.0*(1.0+0.7745*exp(-(3.0*constants[0]-2.05)/0.295))) if eq_func(constants[1], 0.0) else constants[2]*constants[0]/(1.0+0.7745*exp(-(3.0*constants[0]-2.05)/0.295)) if eq_func(constants[1], 1.0) else 1.07*29.0*constants[0]/(30.0*(1.0+0.7745*exp(-(29.0*constants[0]-24.5)/1.95))) + computed_constants[1] = constants[3]+computed_constants[0]*(constants[4]-constants[3]) + computed_constants[3] = constants[8]+computed_constants[0]*(constants[9]-constants[8]) if eq_func(constants[1], 0.0) else constants[12]+computed_constants[0]*(constants[13]-constants[12]) if eq_func(constants[1], 1.0) else constants[10]+computed_constants[0]*(constants[11]-constants[10]) + computed_constants[5] = constants[14]+computed_constants[0]*(constants[15]-constants[14]) if eq_func(constants[1], 0.0) else constants[18]+computed_constants[0]*(constants[19]-constants[18]) if eq_func(constants[1], 1.0) else constants[16]+computed_constants[0]*(constants[17]-constants[16]) + computed_constants[7] = constants[20]+computed_constants[0]*(constants[21]-constants[20]) if eq_func(constants[1], 0.0) else constants[24]+computed_constants[0]*(constants[25]-constants[24]) if eq_func(constants[1], 1.0) else constants[22]+computed_constants[0]*(constants[23]-constants[22]) + computed_constants[9] = constants[26]+computed_constants[0]*(constants[27]-constants[26]) if eq_func(constants[1], 0.0) else constants[30]+computed_constants[0]*(constants[31]-constants[30]) if eq_func(constants[1], 1.0) else constants[28]+computed_constants[0]*(constants[29]-constants[28]) + computed_constants[10] = constants[38]+computed_constants[0]*(constants[39]-constants[38]) if eq_func(constants[1], 0.0) else constants[42]+computed_constants[0]*(constants[43]-constants[42]) if eq_func(constants[1], 1.0) else constants[40]+computed_constants[0]*(constants[41]-constants[40]) + computed_constants[11] = constants[47]+computed_constants[0]*(constants[48]-constants[47]) if eq_func(constants[1], 0.0) else constants[51]+computed_constants[0]*(constants[52]-constants[51]) if eq_func(constants[1], 1.0) else constants[49]+computed_constants[0]*(constants[50]-constants[49]) + computed_constants[2] = computed_constants[11]*constants[36]/(constants[36]+0.0004) + computed_constants[4] = constants[5]*constants[6]/constants[7]*log(constants[35]/constants[32]) + computed_constants[6] = constants[5]*constants[6]/constants[7]*log(constants[44]/constants[53]) + computed_constants[8] = constants[5]*constants[6]/(2.0*constants[7])*log(constants[34]/constants[36]) + computed_constants[12] = constants[5]*constants[6]/constants[7]*log((constants[44]+0.12*constants[35])/(constants[53]+0.12*constants[32])) if eq_func(constants[1], 0.0) else constants[5]*constants[6]/constants[7]*log((constants[44]+0.03*constants[35])/(constants[53]+0.03*constants[32])) + computed_constants[13] = constants[54]+computed_constants[0]*(constants[55]-constants[54]) if eq_func(constants[1], 0.0) else constants[58]+computed_constants[0]*(constants[59]-constants[58]) if eq_func(constants[1], 1.0) else constants[56]+computed_constants[0]*(constants[57]-constants[56]) + computed_constants[14] = constants[60]+computed_constants[0]*(constants[61]-constants[60]) if eq_func(constants[1], 0.0) else constants[64]+computed_constants[0]*(constants[65]-constants[64]) if eq_func(constants[1], 1.0) else constants[62]+computed_constants[0]*(constants[63]-constants[62]) + computed_constants[15] = constants[67]+computed_constants[0]*(constants[68]-constants[67]) if eq_func(constants[1], 0.0) else constants[71]+computed_constants[0]*(constants[72]-constants[71]) if eq_func(constants[1], 1.0) else constants[69]+computed_constants[0]*(constants[70]-constants[69]) + computed_constants[16] = constants[74]+computed_constants[0]*(constants[75]-constants[74]) if eq_func(constants[1], 0.0) else constants[78]+computed_constants[0]*(constants[79]-constants[78]) if eq_func(constants[1], 1.0) else constants[76]+computed_constants[0]*(constants[77]-constants[76]) + computed_constants[17] = constants[80]+computed_constants[0]*(constants[81]-constants[80]) if eq_func(constants[1], 0.0) else constants[84]+computed_constants[0]*(constants[85]-constants[84]) if eq_func(constants[1], 1.0) else constants[82]+computed_constants[0]*(constants[83]-constants[82]) + computed_constants[18] = constants[86]+computed_constants[0]*(constants[87]-constants[86]) if eq_func(constants[1], 0.0) else constants[90]+computed_constants[0]*(constants[91]-constants[90]) if eq_func(constants[1], 1.0) else constants[88]+computed_constants[0]*(constants[89]-constants[88]) + computed_constants[19] = 0.002 if eq_func(constants[1], 0.0) else 0.002 if eq_func(constants[1], 1.0) else 0.006 + computed_constants[20] = constants[92]+computed_constants[0]*(constants[93]-constants[92]) if eq_func(constants[1], 0.0) else constants[96]+computed_constants[0]*(constants[97]-constants[96]) if eq_func(constants[1], 1.0) else constants[94]+computed_constants[0]*(constants[95]-constants[94]) + computed_constants[21] = constants[98]+computed_constants[0]*(constants[99]-constants[98]) if eq_func(constants[1], 0.0) else constants[102]+computed_constants[0]*(constants[103]-constants[102]) if eq_func(constants[1], 1.0) else constants[100]+computed_constants[0]*(constants[101]-constants[100]) + computed_constants[22] = constants[104]+computed_constants[0]*(constants[105]-constants[104]) if eq_func(constants[1], 0.0) else constants[108]+computed_constants[0]*(constants[109]-constants[108]) if eq_func(constants[1], 1.0) else constants[106]+computed_constants[0]*(constants[107]-constants[106]) def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[9] = computed_constants[62]*pow(constants[56]/(constants[71]+constants[56]), 3.0)*pow(constants[69]/(constants[70]+constants[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) - algebraic[10] = computed_constants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.0374*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))) if eq_func(constants[2], 0.0) else computed_constants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.03743*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))) - algebraic[14] = computed_constants[176]*states[14]*(states[0]-computed_constants[40]) if neq_func(constants[2], 2.0) else computed_constants[176]*states[14]*(states[0]+102.0) - algebraic[15] = computed_constants[169]*states[14]*(states[0]-computed_constants[32]) if neq_func(constants[2], 2.0) else computed_constants[169]*states[14]*(states[0]-77.6) - algebraic[16] = computed_constants[160]*pow(states[13], 2.0)*(states[0]-computed_constants[80]) - algebraic[18] = computed_constants[135]*states[8]*(states[0]-computed_constants[40]) - algebraic[19] = computed_constants[128]*states[9]*states[8]*(states[0]-computed_constants[40]) - algebraic[20] = computed_constants[112]*states[7]*states[6]*(states[0]-constants[119]) - algebraic[21] = computed_constants[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[103]) - algebraic[91] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[2], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 - algebraic[88] = (1.0-algebraic[91])*states[2]+algebraic[91]*states[3] - algebraic[7] = computed_constants[81]*pow(states[1], 3.0)*algebraic[88]*constants[59]*pow(constants[24], 2.0)/(constants[22]*constants[23])*(exp((states[0]-computed_constants[32])*constants[24]/(constants[22]*constants[23]))-1.0)/(exp(states[0]*constants[24]/(constants[22]*constants[23]))-1.0)*states[0] - algebraic[11] = computed_constants[33]*(states[0]-computed_constants[40]) - algebraic[12] = computed_constants[41]*(states[0]-computed_constants[48]) - algebraic[13] = computed_constants[25]*(states[0]-computed_constants[32]) - algebraic[153] = 0.6*states[11]+0.4*states[12] - algebraic[17] = computed_constants[146]*algebraic[153]*states[10]*(states[0]-computed_constants[40]) - rates[0] = -1.0/computed_constants[4]*(algebraic[7]+algebraic[21]+algebraic[20]+algebraic[19]+algebraic[18]+algebraic[17]+algebraic[16]+algebraic[15]+algebraic[14]+algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+computed_constants[8]) - algebraic[89] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[2], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) - algebraic[90] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[2], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 - rates[1] = (algebraic[89]-states[1])/algebraic[90] - algebraic[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) - algebraic[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 - rates[2] = (algebraic[92]-states[2])/algebraic[93] - algebraic[94] = algebraic[92] - algebraic[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 - rates[3] = (algebraic[94]-states[3])/algebraic[95] - algebraic[104] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[2], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[2], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) - algebraic[106] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[2], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[2], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) - algebraic[107] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[2], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) - algebraic[105] = 2.0/(algebraic[106]+algebraic[107]) - rates[5] = (algebraic[104]-states[5])/algebraic[105] - algebraic[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) - algebraic[110] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[2], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) - algebraic[111] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[2], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) - algebraic[109] = (1.2-0.2*computed_constants[0])/(algebraic[110]+algebraic[111]) if eq_func(constants[2], 1.0) else 1.0/(algebraic[110]+algebraic[111]) - rates[4] = (algebraic[108]-states[4])/algebraic[109] - algebraic[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) - algebraic[122] = 1068.0*exp((states[0]+26.3)/30.0) - algebraic[123] = 1068.0*exp(-(states[0]+26.3)/30.0) - algebraic[121] = 1.0/(algebraic[122]+algebraic[123]) - rates[7] = (algebraic[120]-states[7])/algebraic[121] - algebraic[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) - algebraic[126] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[2], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) - algebraic[127] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[2], 1.0) else 15.0*exp((states[0]+71.7)/15.38) - algebraic[125] = 1.0/(algebraic[126]+algebraic[127]) - rates[6] = (algebraic[124]-states[6])/algebraic[125] - algebraic[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) - algebraic[143] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[2], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[2], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) - rates[9] = (algebraic[142]-states[9])/algebraic[143] - algebraic[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) - algebraic[145] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[2], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[2], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) - rates[8] = (algebraic[144]-states[8])/algebraic[145] - algebraic[154] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[2], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) - algebraic[155] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[2], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) - rates[11] = (algebraic[154]-states[11])/algebraic[155] - algebraic[156] = algebraic[154] - algebraic[157] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[2], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) - rates[12] = (algebraic[156]-states[12])/algebraic[157] - algebraic[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) - rates[10] = (algebraic[159]-states[10])/computed_constants[158] - algebraic[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) - algebraic[168] = 1.0*exp(-states[0]/45.0) - rates[13] = algebraic[167]*(1.0-states[13])-algebraic[168]*states[13] - algebraic[183] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[2], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) - algebraic[184] = 1.0*exp((states[0]+75.13)/21.25) - rates[14] = algebraic[183]*(1.0-states[14])-algebraic[184]*states[14] + algebraic[1] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) + algebraic[2] = computed_constants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.0374*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.03743*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))) + algebraic[6] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) + algebraic[7] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) + algebraic[8] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) + algebraic[10] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) + algebraic[11] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) + algebraic[12] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) + algebraic[13] = computed_constants[14]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) + algebraic[17] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[1], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 + algebraic[14] = (1.0-algebraic[17])*states[2]+algebraic[17]*states[3] + algebraic[0] = computed_constants[13]*pow(states[1], 3.0)*algebraic[14]*constants[35]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] + algebraic[3] = computed_constants[5]*(states[0]-computed_constants[6]) + algebraic[4] = computed_constants[7]*(states[0]-computed_constants[8]) + algebraic[5] = computed_constants[3]*(states[0]-computed_constants[4]) + algebraic[42] = 0.6*states[11]+0.4*states[12] + algebraic[9] = computed_constants[18]*algebraic[42]*states[10]*(states[0]-computed_constants[6]) + rates[0] = -1.0/computed_constants[1]*(algebraic[0]+algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+algebraic[8]+algebraic[7]+algebraic[6]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[2]+algebraic[1]+computed_constants[2]) + algebraic[15] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) + algebraic[16] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 + rates[1] = (algebraic[15]-states[1])/algebraic[16] + algebraic[18] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) + algebraic[19] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 + rates[2] = (algebraic[18]-states[2])/algebraic[19] + algebraic[20] = algebraic[18] + algebraic[21] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 + rates[3] = (algebraic[20]-states[3])/algebraic[21] + algebraic[22] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) + algebraic[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) + algebraic[25] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[1], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) + algebraic[23] = 2.0/(algebraic[24]+algebraic[25]) + rates[5] = (algebraic[22]-states[5])/algebraic[23] + algebraic[26] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) + algebraic[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) + algebraic[29] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) + algebraic[27] = (1.2-0.2*computed_constants[0])/(algebraic[28]+algebraic[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraic[28]+algebraic[29]) + rates[4] = (algebraic[26]-states[4])/algebraic[27] + algebraic[30] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) + algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0) + algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0) + algebraic[31] = 1.0/(algebraic[32]+algebraic[33]) + rates[7] = (algebraic[30]-states[7])/algebraic[31] + algebraic[34] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) + algebraic[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) + algebraic[37] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[1], 1.0) else 15.0*exp((states[0]+71.7)/15.38) + algebraic[35] = 1.0/(algebraic[36]+algebraic[37]) + rates[6] = (algebraic[34]-states[6])/algebraic[35] + algebraic[38] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) + algebraic[39] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) + rates[9] = (algebraic[38]-states[9])/algebraic[39] + algebraic[40] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) + algebraic[41] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) + rates[8] = (algebraic[40]-states[8])/algebraic[41] + algebraic[43] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) + algebraic[44] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) + rates[11] = (algebraic[43]-states[11])/algebraic[44] + algebraic[45] = algebraic[43] + algebraic[46] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) + rates[12] = (algebraic[45]-states[12])/algebraic[46] + algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) + rates[10] = (algebraic[47]-states[10])/computed_constants[19] + algebraic[48] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) + algebraic[49] = 1.0*exp(-states[0]/45.0) + rates[13] = algebraic[48]*(1.0-states[13])-algebraic[49]*states[13] + algebraic[50] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) + algebraic[51] = 1.0*exp((states[0]+75.13)/21.25) + rates[14] = algebraic[50]*(1.0-states[14])-algebraic[51]*states[14] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[13] = computed_constants[25]*(states[0]-computed_constants[32]) - algebraic[11] = computed_constants[33]*(states[0]-computed_constants[40]) - algebraic[12] = computed_constants[41]*(states[0]-computed_constants[48]) - algebraic[10] = computed_constants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.0374*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))) if eq_func(constants[2], 0.0) else computed_constants[49]*(pow(constants[56], 3.0)*constants[58]*exp(0.03743*states[0]*constants[57])-pow(constants[59], 3.0)*constants[60]*exp(0.03743*states[0]*(constants[57]-1.0)))/(1.0+constants[61]*(constants[60]*pow(constants[59], 3.0)+constants[58]*pow(constants[56], 3.0))) - algebraic[9] = computed_constants[62]*pow(constants[56]/(constants[71]+constants[56]), 3.0)*pow(constants[69]/(constants[70]+constants[69]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) - algebraic[91] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[2], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 - algebraic[88] = (1.0-algebraic[91])*states[2]+algebraic[91]*states[3] - algebraic[7] = computed_constants[81]*pow(states[1], 3.0)*algebraic[88]*constants[59]*pow(constants[24], 2.0)/(constants[22]*constants[23])*(exp((states[0]-computed_constants[32])*constants[24]/(constants[22]*constants[23]))-1.0)/(exp(states[0]*constants[24]/(constants[22]*constants[23]))-1.0)*states[0] - algebraic[89] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[2], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) - algebraic[90] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[2], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 - algebraic[92] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) - algebraic[94] = algebraic[92] - algebraic[93] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 - algebraic[95] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 - algebraic[21] = computed_constants[96]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[103]) - algebraic[106] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[2], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[2], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) - algebraic[107] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[2], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) - algebraic[105] = 2.0/(algebraic[106]+algebraic[107]) - algebraic[104] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[2], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[2], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) - algebraic[110] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[2], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) - algebraic[111] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[2], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) - algebraic[109] = (1.2-0.2*computed_constants[0])/(algebraic[110]+algebraic[111]) if eq_func(constants[2], 1.0) else 1.0/(algebraic[110]+algebraic[111]) - algebraic[108] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) - algebraic[20] = computed_constants[112]*states[7]*states[6]*(states[0]-constants[119]) - algebraic[122] = 1068.0*exp((states[0]+26.3)/30.0) - algebraic[123] = 1068.0*exp(-(states[0]+26.3)/30.0) - algebraic[121] = 1.0/(algebraic[122]+algebraic[123]) - algebraic[120] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) - algebraic[126] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[2], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) - algebraic[127] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[2], 1.0) else 15.0*exp((states[0]+71.7)/15.38) - algebraic[125] = 1.0/(algebraic[126]+algebraic[127]) - algebraic[124] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) - algebraic[19] = computed_constants[128]*states[9]*states[8]*(states[0]-computed_constants[40]) - algebraic[18] = computed_constants[135]*states[8]*(states[0]-computed_constants[40]) - algebraic[142] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) - algebraic[143] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[2], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[2], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) - algebraic[144] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) - algebraic[145] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[2], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[2], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) - algebraic[153] = 0.6*states[11]+0.4*states[12] - algebraic[17] = computed_constants[146]*algebraic[153]*states[10]*(states[0]-computed_constants[40]) - algebraic[154] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[2], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) - algebraic[155] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[2], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) - algebraic[156] = algebraic[154] - algebraic[157] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[2], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) - algebraic[159] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) - algebraic[16] = computed_constants[160]*pow(states[13], 2.0)*(states[0]-computed_constants[80]) - algebraic[167] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) - algebraic[168] = 1.0*exp(-states[0]/45.0) - algebraic[15] = computed_constants[169]*states[14]*(states[0]-computed_constants[32]) if neq_func(constants[2], 2.0) else computed_constants[169]*states[14]*(states[0]-77.6) - algebraic[14] = computed_constants[176]*states[14]*(states[0]-computed_constants[40]) if neq_func(constants[2], 2.0) else computed_constants[176]*states[14]*(states[0]+102.0) - algebraic[183] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[2], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) - algebraic[184] = 1.0*exp((states[0]+75.13)/21.25) + algebraic[5] = computed_constants[3]*(states[0]-computed_constants[4]) + algebraic[3] = computed_constants[5]*(states[0]-computed_constants[6]) + algebraic[4] = computed_constants[7]*(states[0]-computed_constants[8]) + algebraic[2] = computed_constants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.0374*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.03743*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))) + algebraic[1] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) + algebraic[17] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[1], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 + algebraic[14] = (1.0-algebraic[17])*states[2]+algebraic[17]*states[3] + algebraic[0] = computed_constants[13]*pow(states[1], 3.0)*algebraic[14]*constants[35]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] + algebraic[15] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) + algebraic[16] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 + algebraic[18] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) + algebraic[20] = algebraic[18] + algebraic[19] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 + algebraic[21] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 + algebraic[13] = computed_constants[14]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) + algebraic[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) + algebraic[25] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[1], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) + algebraic[23] = 2.0/(algebraic[24]+algebraic[25]) + algebraic[22] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) + algebraic[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) + algebraic[29] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) + algebraic[27] = (1.2-0.2*computed_constants[0])/(algebraic[28]+algebraic[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraic[28]+algebraic[29]) + algebraic[26] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) + algebraic[12] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) + algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0) + algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0) + algebraic[31] = 1.0/(algebraic[32]+algebraic[33]) + algebraic[30] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) + algebraic[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) + algebraic[37] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[1], 1.0) else 15.0*exp((states[0]+71.7)/15.38) + algebraic[35] = 1.0/(algebraic[36]+algebraic[37]) + algebraic[34] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) + algebraic[11] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) + algebraic[10] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) + algebraic[38] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) + algebraic[39] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) + algebraic[40] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) + algebraic[41] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) + algebraic[42] = 0.6*states[11]+0.4*states[12] + algebraic[9] = computed_constants[18]*algebraic[42]*states[10]*(states[0]-computed_constants[6]) + algebraic[43] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) + algebraic[44] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) + algebraic[45] = algebraic[43] + algebraic[46] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) + algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) + algebraic[8] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) + algebraic[48] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) + algebraic[49] = 1.0*exp(-states[0]/45.0) + algebraic[7] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) + algebraic[6] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) + algebraic[50] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) + algebraic[51] = 1.0*exp((states[0]+75.13)/21.25) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index df6f7da7a..fd4eb1dfc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -72,11 +72,11 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - constants[4] = 1.0; - constants[5] = 0.0; - constants[7] = 0.3; - constants[9] = 120.0; - constants[15] = 36.0; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; @@ -86,39 +86,39 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[6] = constants[5]-10.613; - computedConstants[8] = constants[5]-115.0; - computedConstants[14] = constants[5]+12.0; + computedConstants[0] = constants[1]-10.613; + computedConstants[1] = constants[1]-115.0; + computedConstants[2] = constants[1]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; + algebraic[1] = constants[2]*(states[0]-computedConstants[0]); + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); + algebraic[1] = constants[2]*(states[0]-computedConstants[0]); + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index e287d4bc5..9b752f340 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -74,11 +74,11 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - constants[4] = 1.0 - constants[5] = 0.0 - constants[7] = 0.3 - constants[9] = 120.0 - constants[15] = 36.0 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -87,36 +87,36 @@ def initialise_variables(voi, states, rates, constants, external_variable): def compute_computed_constants(constants, computed_constants): - computed_constants[6] = constants[5]-10.613 - computed_constants[8] = constants[5]-115.0 - computed_constants[14] = constants[5]+12.0 + computed_constants[0] = constants[1]-10.613 + computed_constants[1] = constants[1]-115.0 + computed_constants[2] = constants[1]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] + algebraic[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) + algebraic[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 0c24c18ef..33d70c70c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -72,11 +72,11 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - constants[4] = 1.0; - constants[5] = 0.0; - constants[7] = 0.3; - constants[9] = 120.0; - constants[15] = 36.0; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; @@ -85,38 +85,38 @@ void initialiseVariables(double *states, double *rates, double *constants) void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[6] = constants[5]-10.613; - computedConstants[8] = constants[5]-115.0; - computedConstants[14] = constants[5]+12.0; + computedConstants[0] = constants[1]-10.613; + computedConstants[1] = constants[1]-115.0; + computedConstants[2] = constants[1]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; + algebraic[1] = constants[2]*(states[0]-computedConstants[0]); + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); + algebraic[1] = constants[2]*(states[0]-computedConstants[0]); + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index bf291e2fb..4dd1a09a6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -72,53 +72,53 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - constants[4] = 1.0; - constants[5] = 0.0; - constants[7] = 0.3; - constants[9] = 120.0; - constants[15] = 36.0; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; - algebraic[6] = externalVariable(voi, states, rates, variables, 6); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[8] = constants[5]-115.0; - computedConstants[14] = constants[5]+12.0; + computedConstants[0] = constants[1]-115.0; + computedConstants[1] = constants[1]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[6] = externalVariable(voi, states, rates, variables, 6); - algebraic[1] = constants[7]*(states[0]-algebraic[6]); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; + algebraic[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[1] = constants[2]*(states[0]-algebraic[4]); + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; + algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[6] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[5]*(1.0-states[2])-algebraic[6]*states[2]; + algebraic[7] = 0.07*exp(states[0]/20.0); + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1]; + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[10] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[9]*(1.0-states[3])-algebraic[10]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[6] = externalVariable(voi, states, rates, variables, 6); - algebraic[1] = constants[7]*(states[0]-algebraic[6]); - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[1] = constants[2]*(states[0]-algebraic[4]); + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); + algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[6] = 4.0*exp(states[0]/18.0); + algebraic[7] = 0.07*exp(states[0]/20.0); + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[10] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 2a928ef7f..4d8a09531 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -74,49 +74,49 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - constants[4] = 1.0 - constants[5] = 0.0 - constants[7] = 0.3 - constants[9] = 120.0 - constants[15] = 36.0 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 - algebraic[6] = external_variable(voi, states, rates, variables, 6) + algebraic[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): - computed_constants[8] = constants[5]-115.0 - computed_constants[14] = constants[5]+12.0 + computed_constants[0] = constants[1]-115.0 + computed_constants[1] = constants[1]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[6] = external_variable(voi, states, rates, variables, 6) - algebraic[1] = constants[7]*(states[0]-algebraic[6]) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] + algebraic[4] = external_variable(voi, states, rates, variables, 4) + algebraic[1] = constants[2]*(states[0]-algebraic[4]) + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] + algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[6] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[5]*(1.0-states[2])-algebraic[6]*states[2] + algebraic[7] = 0.07*exp(states[0]/20.0) + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1] + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[10] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[9]*(1.0-states[3])-algebraic[10]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[6] = external_variable(voi, states, rates, variables, 6) - algebraic[1] = constants[7]*(states[0]-algebraic[6]) - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) + algebraic[4] = external_variable(voi, states, rates, variables, 4) + algebraic[1] = constants[2]*(states[0]-algebraic[4]) + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) + algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[6] = 4.0*exp(states[0]/18.0) + algebraic[7] = 0.07*exp(states[0]/20.0) + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[10] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index f3d725514..b38a8dde5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -72,10 +72,10 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - constants[5] = 0.0; - constants[7] = 0.3; - constants[9] = 120.0; - constants[15] = 36.0; + constants[0] = 0.0; + constants[1] = 0.3; + constants[2] = 120.0; + constants[3] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; @@ -85,40 +85,40 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[6] = constants[5]-10.613; - computedConstants[8] = constants[5]-115.0; - computedConstants[14] = constants[5]+12.0; + computedConstants[0] = constants[0]-10.613; + computedConstants[1] = constants[0]-115.0; + computedConstants[2] = constants[0]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraic[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + algebraic[1] = constants[1]*(states[0]-computedConstants[0]); + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4]; - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; + algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[6] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[5]*(1.0-states[2])-algebraic[6]*states[2]; + algebraic[7] = 0.07*exp(states[0]/20.0); + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1]; + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[10] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[9]*(1.0-states[3])-algebraic[10]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); + algebraic[1] = constants[1]*(states[0]-computedConstants[0]); + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[6] = 4.0*exp(states[0]/18.0); + algebraic[7] = 0.07*exp(states[0]/20.0); + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[10] = 0.125*exp(states[0]/80.0); algebraic[4] = externalVariable(voi, states, rates, variables, 4); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 99304a266..9a8335d0d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -74,10 +74,10 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - constants[5] = 0.0 - constants[7] = 0.3 - constants[9] = 120.0 - constants[15] = 36.0 + constants[0] = 0.0 + constants[1] = 0.3 + constants[2] = 120.0 + constants[3] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -86,37 +86,37 @@ def initialise_variables(voi, states, rates, constants, external_variable): def compute_computed_constants(constants, computed_constants): - computed_constants[6] = constants[5]-10.613 - computed_constants[8] = constants[5]-115.0 - computed_constants[14] = constants[5]+12.0 + computed_constants[0] = constants[0]-10.613 + computed_constants[1] = constants[0]-115.0 + computed_constants[2] = constants[0]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic[4] = external_variable(voi, states, rates, variables, 4) - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + algebraic[1] = constants[1]*(states[0]-computed_constants[0]) + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4] - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] + algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[6] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[5]*(1.0-states[2])-algebraic[6]*states[2] + algebraic[7] = 0.07*exp(states[0]/20.0) + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1] + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[10] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[9]*(1.0-states[3])-algebraic[10]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) + algebraic[1] = constants[1]*(states[0]-computed_constants[0]) + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[6] = 4.0*exp(states[0]/18.0) + algebraic[7] = 0.07*exp(states[0]/20.0) + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[10] = 0.125*exp(states[0]/80.0) algebraic[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 79d7df082..228073aca 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -113,7 +113,7 @@ void objectiveFunction1(double *u, double *f, void *data) rates[0] = u[0]; - f[0] = rates[0]-(-(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4])-0.0; + f[0] = rates[0]-(-(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0])-0.0; } void findRoot1(double voi, double *states, double *rates, double *variables) @@ -135,9 +135,9 @@ void objectiveFunction2(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - computedConstants[6] = u[0]; + computedConstants[0] = u[0]; - f[0] = computedConstants[6]-(constants[5]-10.613)-0.0; + f[0] = computedConstants[0]-(constants[1]-10.613)-0.0; } void findRoot2(double voi, double *states, double *rates, double *variables) @@ -145,11 +145,11 @@ void findRoot2(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[6]; + u[0] = algebraic[0]; nlaSolve(objectiveFunction2, u, 1, &rfi); - algebraic[6] = u[0]; + algebraic[0] = u[0]; } void objectiveFunction3(double *u, double *f, void *data) @@ -161,7 +161,7 @@ void objectiveFunction3(double *u, double *f, void *data) algebraic[1] = u[0]; - f[0] = algebraic[1]-constants[7]*(states[0]-computedConstants[6])-0.0; + f[0] = algebraic[1]-constants[2]*(states[0]-computedConstants[0])-0.0; } void findRoot3(double voi, double *states, double *rates, double *variables) @@ -183,9 +183,9 @@ void objectiveFunction4(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - computedConstants[8] = u[0]; + computedConstants[1] = u[0]; - f[0] = computedConstants[8]-(constants[5]-115.0)-0.0; + f[0] = computedConstants[1]-(constants[1]-115.0)-0.0; } void findRoot4(double voi, double *states, double *rates, double *variables) @@ -193,11 +193,11 @@ void findRoot4(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[8]; + u[0] = algebraic[1]; nlaSolve(objectiveFunction4, u, 1, &rfi); - algebraic[8] = u[0]; + algebraic[1] = u[0]; } void objectiveFunction5(double *u, double *f, void *data) @@ -209,7 +209,7 @@ void objectiveFunction5(double *u, double *f, void *data) algebraic[3] = u[0]; - f[0] = algebraic[3]-constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8])-0.0; + f[0] = algebraic[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1])-0.0; } void findRoot5(double voi, double *states, double *rates, double *variables) @@ -231,9 +231,9 @@ void objectiveFunction6(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[10] = u[0]; + algebraic[4] = u[0]; - f[0] = algebraic[10]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0; + f[0] = algebraic[4]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0; } void findRoot6(double voi, double *states, double *rates, double *variables) @@ -241,11 +241,11 @@ void findRoot6(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[10]; + u[0] = algebraic[4]; nlaSolve(objectiveFunction6, u, 1, &rfi); - algebraic[10] = u[0]; + algebraic[4] = u[0]; } void objectiveFunction7(double *u, double *f, void *data) @@ -255,9 +255,9 @@ void objectiveFunction7(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[11] = u[0]; + algebraic[5] = u[0]; - f[0] = algebraic[11]-4.0*exp(states[0]/18.0)-0.0; + f[0] = algebraic[5]-4.0*exp(states[0]/18.0)-0.0; } void findRoot7(double voi, double *states, double *rates, double *variables) @@ -265,11 +265,11 @@ void findRoot7(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[11]; + u[0] = algebraic[5]; nlaSolve(objectiveFunction7, u, 1, &rfi); - algebraic[11] = u[0]; + algebraic[5] = u[0]; } void objectiveFunction8(double *u, double *f, void *data) @@ -281,7 +281,7 @@ void objectiveFunction8(double *u, double *f, void *data) rates[2] = u[0]; - f[0] = rates[2]-(algebraic[10]*(1.0-states[2])-algebraic[11]*states[2])-0.0; + f[0] = rates[2]-(algebraic[4]*(1.0-states[2])-algebraic[5]*states[2])-0.0; } void findRoot8(double voi, double *states, double *rates, double *variables) @@ -303,9 +303,9 @@ void objectiveFunction9(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[12] = u[0]; + algebraic[6] = u[0]; - f[0] = algebraic[12]-0.07*exp(states[0]/20.0)-0.0; + f[0] = algebraic[6]-0.07*exp(states[0]/20.0)-0.0; } void findRoot9(double voi, double *states, double *rates, double *variables) @@ -313,11 +313,11 @@ void findRoot9(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[12]; + u[0] = algebraic[6]; nlaSolve(objectiveFunction9, u, 1, &rfi); - algebraic[12] = u[0]; + algebraic[6] = u[0]; } void objectiveFunction10(double *u, double *f, void *data) @@ -327,9 +327,9 @@ void objectiveFunction10(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[13] = u[0]; + algebraic[7] = u[0]; - f[0] = algebraic[13]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; + f[0] = algebraic[7]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; } void findRoot10(double voi, double *states, double *rates, double *variables) @@ -337,11 +337,11 @@ void findRoot10(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[13]; + u[0] = algebraic[7]; nlaSolve(objectiveFunction10, u, 1, &rfi); - algebraic[13] = u[0]; + algebraic[7] = u[0]; } void objectiveFunction11(double *u, double *f, void *data) @@ -353,7 +353,7 @@ void objectiveFunction11(double *u, double *f, void *data) rates[1] = u[0]; - f[0] = rates[1]-(algebraic[12]*(1.0-states[1])-algebraic[13]*states[1])-0.0; + f[0] = rates[1]-(algebraic[6]*(1.0-states[1])-algebraic[7]*states[1])-0.0; } void findRoot11(double voi, double *states, double *rates, double *variables) @@ -375,9 +375,9 @@ void objectiveFunction12(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - computedConstants[14] = u[0]; + computedConstants[2] = u[0]; - f[0] = computedConstants[14]-(constants[5]+12.0)-0.0; + f[0] = computedConstants[2]-(constants[1]+12.0)-0.0; } void findRoot12(double voi, double *states, double *rates, double *variables) @@ -385,11 +385,11 @@ void findRoot12(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[14]; + u[0] = algebraic[2]; nlaSolve(objectiveFunction12, u, 1, &rfi); - algebraic[14] = u[0]; + algebraic[2] = u[0]; } void objectiveFunction13(double *u, double *f, void *data) @@ -401,7 +401,7 @@ void objectiveFunction13(double *u, double *f, void *data) algebraic[2] = u[0]; - f[0] = algebraic[2]-constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14])-0.0; + f[0] = algebraic[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2])-0.0; } void findRoot13(double voi, double *states, double *rates, double *variables) @@ -423,9 +423,9 @@ void objectiveFunction14(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[16] = u[0]; + algebraic[8] = u[0]; - f[0] = algebraic[16]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; + f[0] = algebraic[8]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; } void findRoot14(double voi, double *states, double *rates, double *variables) @@ -433,11 +433,11 @@ void findRoot14(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[16]; + u[0] = algebraic[8]; nlaSolve(objectiveFunction14, u, 1, &rfi); - algebraic[16] = u[0]; + algebraic[8] = u[0]; } void objectiveFunction15(double *u, double *f, void *data) @@ -447,9 +447,9 @@ void objectiveFunction15(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[17] = u[0]; + algebraic[9] = u[0]; - f[0] = algebraic[17]-0.125*exp(states[0]/80.0)-0.0; + f[0] = algebraic[9]-0.125*exp(states[0]/80.0)-0.0; } void findRoot15(double voi, double *states, double *rates, double *variables) @@ -457,11 +457,11 @@ void findRoot15(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[17]; + u[0] = algebraic[9]; nlaSolve(objectiveFunction15, u, 1, &rfi); - algebraic[17] = u[0]; + algebraic[9] = u[0]; } void objectiveFunction16(double *u, double *f, void *data) @@ -473,7 +473,7 @@ void objectiveFunction16(double *u, double *f, void *data) rates[3] = u[0]; - f[0] = rates[3]-(algebraic[16]*(1.0-states[3])-algebraic[17]*states[3])-0.0; + f[0] = rates[3]-(algebraic[8]*(1.0-states[3])-algebraic[9]*states[3])-0.0; } void findRoot16(double voi, double *states, double *rates, double *variables) @@ -494,20 +494,20 @@ void initialiseVariables(double *states, double *rates, double *constants) algebraic[1] = 0.0; algebraic[2] = 0.0; algebraic[3] = 0.0; - constants[4] = 1.0; - constants[5] = 0.0; - computedConstants[6] = 0.0; - constants[7] = 0.3; - computedConstants[8] = 0.0; - constants[9] = 120.0; - algebraic[10] = 0.0; - algebraic[11] = 0.0; - algebraic[12] = 0.0; - algebraic[13] = 0.0; - computedConstants[14] = 0.0; - constants[15] = 36.0; - algebraic[16] = 0.0; - algebraic[17] = 0.0; + constants[0] = 1.0; + constants[1] = 0.0; + computedConstants[0] = 0.0; + constants[2] = 0.3; + computedConstants[1] = 0.0; + constants[3] = 120.0; + algebraic[4] = 0.0; + algebraic[5] = 0.0; + algebraic[6] = 0.0; + algebraic[7] = 0.0; + computedConstants[2] = 0.0; + constants[4] = 36.0; + algebraic[8] = 0.0; + algebraic[9] = 0.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 068073cbd..e9fe6851d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -104,7 +104,7 @@ def objective_function_1(u, f, data): rates[0] = u[0] - f[0] = rates[0]-(-(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4])-0.0 + f[0] = rates[0]-(-(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0])-0.0 def find_root_1(voi, states, rates, variables): @@ -123,19 +123,19 @@ def objective_function_2(u, f, data): rates = data[2] variables = data[3] - computed_constants[6] = u[0] + computed_constants[0] = u[0] - f[0] = computed_constants[6]-(constants[5]-10.613)-0.0 + f[0] = computed_constants[0]-(constants[1]-10.613)-0.0 def find_root_2(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[6] + u[0] = algebraic[0] u = nla_solve(objective_function_2, u, 1, [voi, states, rates, variables]) - algebraic[6] = u[0] + algebraic[0] = u[0] def objective_function_3(u, f, data): @@ -146,7 +146,7 @@ def objective_function_3(u, f, data): algebraic[1] = u[0] - f[0] = algebraic[1]-constants[7]*(states[0]-computed_constants[6])-0.0 + f[0] = algebraic[1]-constants[2]*(states[0]-computed_constants[0])-0.0 def find_root_3(voi, states, rates, variables): @@ -165,19 +165,19 @@ def objective_function_4(u, f, data): rates = data[2] variables = data[3] - computed_constants[8] = u[0] + computed_constants[1] = u[0] - f[0] = computed_constants[8]-(constants[5]-115.0)-0.0 + f[0] = computed_constants[1]-(constants[1]-115.0)-0.0 def find_root_4(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[8] + u[0] = algebraic[1] u = nla_solve(objective_function_4, u, 1, [voi, states, rates, variables]) - algebraic[8] = u[0] + algebraic[1] = u[0] def objective_function_5(u, f, data): @@ -188,7 +188,7 @@ def objective_function_5(u, f, data): algebraic[3] = u[0] - f[0] = algebraic[3]-constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8])-0.0 + f[0] = algebraic[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1])-0.0 def find_root_5(voi, states, rates, variables): @@ -207,19 +207,19 @@ def objective_function_6(u, f, data): rates = data[2] variables = data[3] - algebraic[10] = u[0] + algebraic[4] = u[0] - f[0] = algebraic[10]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0 + f[0] = algebraic[4]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0 def find_root_6(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[10] + u[0] = algebraic[4] u = nla_solve(objective_function_6, u, 1, [voi, states, rates, variables]) - algebraic[10] = u[0] + algebraic[4] = u[0] def objective_function_7(u, f, data): @@ -228,19 +228,19 @@ def objective_function_7(u, f, data): rates = data[2] variables = data[3] - algebraic[11] = u[0] + algebraic[5] = u[0] - f[0] = algebraic[11]-4.0*exp(states[0]/18.0)-0.0 + f[0] = algebraic[5]-4.0*exp(states[0]/18.0)-0.0 def find_root_7(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[11] + u[0] = algebraic[5] u = nla_solve(objective_function_7, u, 1, [voi, states, rates, variables]) - algebraic[11] = u[0] + algebraic[5] = u[0] def objective_function_8(u, f, data): @@ -251,7 +251,7 @@ def objective_function_8(u, f, data): rates[2] = u[0] - f[0] = rates[2]-(algebraic[10]*(1.0-states[2])-algebraic[11]*states[2])-0.0 + f[0] = rates[2]-(algebraic[4]*(1.0-states[2])-algebraic[5]*states[2])-0.0 def find_root_8(voi, states, rates, variables): @@ -270,19 +270,19 @@ def objective_function_9(u, f, data): rates = data[2] variables = data[3] - algebraic[12] = u[0] + algebraic[6] = u[0] - f[0] = algebraic[12]-0.07*exp(states[0]/20.0)-0.0 + f[0] = algebraic[6]-0.07*exp(states[0]/20.0)-0.0 def find_root_9(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[12] + u[0] = algebraic[6] u = nla_solve(objective_function_9, u, 1, [voi, states, rates, variables]) - algebraic[12] = u[0] + algebraic[6] = u[0] def objective_function_10(u, f, data): @@ -291,19 +291,19 @@ def objective_function_10(u, f, data): rates = data[2] variables = data[3] - algebraic[13] = u[0] + algebraic[7] = u[0] - f[0] = algebraic[13]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 + f[0] = algebraic[7]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 def find_root_10(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[13] + u[0] = algebraic[7] u = nla_solve(objective_function_10, u, 1, [voi, states, rates, variables]) - algebraic[13] = u[0] + algebraic[7] = u[0] def objective_function_11(u, f, data): @@ -314,7 +314,7 @@ def objective_function_11(u, f, data): rates[1] = u[0] - f[0] = rates[1]-(algebraic[12]*(1.0-states[1])-algebraic[13]*states[1])-0.0 + f[0] = rates[1]-(algebraic[6]*(1.0-states[1])-algebraic[7]*states[1])-0.0 def find_root_11(voi, states, rates, variables): @@ -333,19 +333,19 @@ def objective_function_12(u, f, data): rates = data[2] variables = data[3] - computed_constants[14] = u[0] + computed_constants[2] = u[0] - f[0] = computed_constants[14]-(constants[5]+12.0)-0.0 + f[0] = computed_constants[2]-(constants[1]+12.0)-0.0 def find_root_12(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[14] + u[0] = algebraic[2] u = nla_solve(objective_function_12, u, 1, [voi, states, rates, variables]) - algebraic[14] = u[0] + algebraic[2] = u[0] def objective_function_13(u, f, data): @@ -356,7 +356,7 @@ def objective_function_13(u, f, data): algebraic[2] = u[0] - f[0] = algebraic[2]-constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14])-0.0 + f[0] = algebraic[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2])-0.0 def find_root_13(voi, states, rates, variables): @@ -375,19 +375,19 @@ def objective_function_14(u, f, data): rates = data[2] variables = data[3] - algebraic[16] = u[0] + algebraic[8] = u[0] - f[0] = algebraic[16]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 + f[0] = algebraic[8]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 def find_root_14(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[16] + u[0] = algebraic[8] u = nla_solve(objective_function_14, u, 1, [voi, states, rates, variables]) - algebraic[16] = u[0] + algebraic[8] = u[0] def objective_function_15(u, f, data): @@ -396,19 +396,19 @@ def objective_function_15(u, f, data): rates = data[2] variables = data[3] - algebraic[17] = u[0] + algebraic[9] = u[0] - f[0] = algebraic[17]-0.125*exp(states[0]/80.0)-0.0 + f[0] = algebraic[9]-0.125*exp(states[0]/80.0)-0.0 def find_root_15(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[17] + u[0] = algebraic[9] u = nla_solve(objective_function_15, u, 1, [voi, states, rates, variables]) - algebraic[17] = u[0] + algebraic[9] = u[0] def objective_function_16(u, f, data): @@ -419,7 +419,7 @@ def objective_function_16(u, f, data): rates[3] = u[0] - f[0] = rates[3]-(algebraic[16]*(1.0-states[3])-algebraic[17]*states[3])-0.0 + f[0] = rates[3]-(algebraic[8]*(1.0-states[3])-algebraic[9]*states[3])-0.0 def find_root_16(voi, states, rates, variables): @@ -437,20 +437,20 @@ def initialise_variables(states, rates, constants): algebraic[1] = 0.0 algebraic[2] = 0.0 algebraic[3] = 0.0 - constants[4] = 1.0 - constants[5] = 0.0 - computed_constants[6] = 0.0 - constants[7] = 0.3 - computed_constants[8] = 0.0 - constants[9] = 120.0 - algebraic[10] = 0.0 - algebraic[11] = 0.0 - algebraic[12] = 0.0 - algebraic[13] = 0.0 - computed_constants[14] = 0.0 - constants[15] = 36.0 - algebraic[16] = 0.0 - algebraic[17] = 0.0 + constants[0] = 1.0 + constants[1] = 0.0 + computed_constants[0] = 0.0 + constants[2] = 0.3 + computed_constants[1] = 0.0 + constants[3] = 120.0 + algebraic[4] = 0.0 + algebraic[5] = 0.0 + algebraic[6] = 0.0 + algebraic[7] = 0.0 + computed_constants[2] = 0.0 + constants[4] = 36.0 + algebraic[8] = 0.0 + algebraic[9] = 0.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 9533f72f5..196709742 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -72,54 +72,54 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - constants[4] = 1.0; - constants[5] = 0.0; - constants[7] = 0.3; - constants[9] = 120.0; - constants[15] = 36.0; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; - algebraic[17] = externalVariable(voi, states, rates, variables, 17); + algebraic[9] = externalVariable(voi, states, rates, variables, 9); algebraic[0] = externalVariable(voi, states, rates, variables, 0); } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[6] = constants[5]-10.613; - computedConstants[8] = constants[5]-115.0; - computedConstants[14] = constants[5]+12.0; + computedConstants[0] = constants[1]-10.613; + computedConstants[1] = constants[1]-115.0; + computedConstants[2] = constants[1]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[17] = externalVariable(voi, states, rates, variables, 17); + algebraic[9] = externalVariable(voi, states, rates, variables, 9); algebraic[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; + algebraic[1] = constants[2]*(states[0]-computedConstants[0]); + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[17] = externalVariable(voi, states, rates, variables, 17); + algebraic[9] = externalVariable(voi, states, rates, variables, 9); algebraic[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[1] = constants[2]*(states[0]-computedConstants[0]); + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 381f0a24f..006bf3b12 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -74,50 +74,50 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - constants[4] = 1.0 - constants[5] = 0.0 - constants[7] = 0.3 - constants[9] = 120.0 - constants[15] = 36.0 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 - algebraic[17] = external_variable(voi, states, rates, variables, 17) + algebraic[9] = external_variable(voi, states, rates, variables, 9) algebraic[0] = external_variable(voi, states, rates, variables, 0) def compute_computed_constants(constants, computed_constants): - computed_constants[6] = constants[5]-10.613 - computed_constants[8] = constants[5]-115.0 - computed_constants[14] = constants[5]+12.0 + computed_constants[0] = constants[1]-10.613 + computed_constants[1] = constants[1]-115.0 + computed_constants[2] = constants[1]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[17] = external_variable(voi, states, rates, variables, 17) + algebraic[9] = external_variable(voi, states, rates, variables, 9) algebraic[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] + algebraic[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[17] = external_variable(voi, states, rates, variables, 17) + algebraic[9] = external_variable(voi, states, rates, variables, 9) algebraic[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 4a61f2b74..96ead04c7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -72,16 +72,16 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - constants[4] = 1.0; - constants[7] = 0.3; - constants[9] = 120.0; - constants[15] = 36.0; + constants[0] = 1.0; + constants[1] = 0.3; + constants[2] = 120.0; + constants[3] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; - algebraic[14] = externalVariable(voi, states, rates, variables, 14); - algebraic[5] = externalVariable(voi, states, rates, variables, 5); + algebraic[11] = externalVariable(voi, states, rates, variables, 11); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) @@ -91,38 +91,38 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[14] = externalVariable(voi, states, rates, variables, 14); - algebraic[5] = externalVariable(voi, states, rates, variables, 5); - algebraic[6] = algebraic[5]-10.613; - algebraic[1] = constants[7]*(states[0]-algebraic[6]); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-algebraic[14]); - algebraic[8] = algebraic[5]-115.0; - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[8]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; + algebraic[11] = externalVariable(voi, states, rates, variables, 11); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[5] = algebraic[4]-10.613; + algebraic[1] = constants[1]*(states[0]-algebraic[5]); + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-algebraic[11]); + algebraic[6] = algebraic[4]-115.0; + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; + algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[8] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[7]*(1.0-states[2])-algebraic[8]*states[2]; + algebraic[9] = 0.07*exp(states[0]/20.0); + algebraic[10] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[9]*(1.0-states[1])-algebraic[10]*states[1]; + algebraic[12] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[13] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[12]*(1.0-states[3])-algebraic[13]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[14] = externalVariable(voi, states, rates, variables, 14); - algebraic[5] = externalVariable(voi, states, rates, variables, 5); - algebraic[6] = algebraic[5]-10.613; - algebraic[1] = constants[7]*(states[0]-algebraic[6]); - algebraic[8] = algebraic[5]-115.0; - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[8]); - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-algebraic[14]); - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); + algebraic[11] = externalVariable(voi, states, rates, variables, 11); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[5] = algebraic[4]-10.613; + algebraic[1] = constants[1]*(states[0]-algebraic[5]); + algebraic[6] = algebraic[4]-115.0; + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]); + algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[8] = 4.0*exp(states[0]/18.0); + algebraic[9] = 0.07*exp(states[0]/20.0); + algebraic[10] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-algebraic[11]); + algebraic[12] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[13] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 53027ad4c..c3a219727 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -74,16 +74,16 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - constants[4] = 1.0 - constants[7] = 0.3 - constants[9] = 120.0 - constants[15] = 36.0 + constants[0] = 1.0 + constants[1] = 0.3 + constants[2] = 120.0 + constants[3] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 - algebraic[14] = external_variable(voi, states, rates, variables, 14) - algebraic[5] = external_variable(voi, states, rates, variables, 5) + algebraic[11] = external_variable(voi, states, rates, variables, 11) + algebraic[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): @@ -92,36 +92,36 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[14] = external_variable(voi, states, rates, variables, 14) - algebraic[5] = external_variable(voi, states, rates, variables, 5) - algebraic[6] = algebraic[5]-10.613 - algebraic[1] = constants[7]*(states[0]-algebraic[6]) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-algebraic[14]) - algebraic[8] = algebraic[5]-115.0 - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[8]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] + algebraic[11] = external_variable(voi, states, rates, variables, 11) + algebraic[4] = external_variable(voi, states, rates, variables, 4) + algebraic[5] = algebraic[4]-10.613 + algebraic[1] = constants[1]*(states[0]-algebraic[5]) + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-algebraic[11]) + algebraic[6] = algebraic[4]-115.0 + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] + algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[8] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[7]*(1.0-states[2])-algebraic[8]*states[2] + algebraic[9] = 0.07*exp(states[0]/20.0) + algebraic[10] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[9]*(1.0-states[1])-algebraic[10]*states[1] + algebraic[12] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[13] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[12]*(1.0-states[3])-algebraic[13]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[14] = external_variable(voi, states, rates, variables, 14) - algebraic[5] = external_variable(voi, states, rates, variables, 5) - algebraic[6] = algebraic[5]-10.613 - algebraic[1] = constants[7]*(states[0]-algebraic[6]) - algebraic[8] = algebraic[5]-115.0 - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[8]) - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-algebraic[14]) - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) + algebraic[11] = external_variable(voi, states, rates, variables, 11) + algebraic[4] = external_variable(voi, states, rates, variables, 4) + algebraic[5] = algebraic[4]-10.613 + algebraic[1] = constants[1]*(states[0]-algebraic[5]) + algebraic[6] = algebraic[4]-115.0 + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]) + algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[8] = 4.0*exp(states[0]/18.0) + algebraic[9] = 0.07*exp(states[0]/20.0) + algebraic[10] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-algebraic[11]) + algebraic[12] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[13] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index be516f51b..e78468a05 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -72,55 +72,55 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - constants[5] = 0.0; - constants[7] = 0.3; - constants[15] = 36.0; + constants[0] = 0.0; + constants[1] = 0.3; + constants[2] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; - algebraic[9] = externalVariable(voi, states, rates, variables, 9); + algebraic[5] = externalVariable(voi, states, rates, variables, 5); algebraic[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[6] = constants[5]-10.613; - computedConstants[8] = constants[5]-115.0; - computedConstants[14] = constants[5]+12.0; + computedConstants[0] = constants[0]-10.613; + computedConstants[1] = constants[0]-115.0; + computedConstants[2] = constants[0]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[9] = externalVariable(voi, states, rates, variables, 9); + algebraic[5] = externalVariable(voi, states, rates, variables, 5); algebraic[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[3] = algebraic[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); + algebraic[1] = constants[1]*(states[0]-computedConstants[0]); + algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[3] = algebraic[5]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4]; - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2]; - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1]; - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3]; + algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[7] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2]; + algebraic[8] = 0.07*exp(states[0]/20.0); + algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1]; + algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[11] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[9] = externalVariable(voi, states, rates, variables, 9); - algebraic[3] = algebraic[9]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[8]); - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[11] = 4.0*exp(states[0]/18.0); - algebraic[12] = 0.07*exp(states[0]/20.0); - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computedConstants[14]); - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[17] = 0.125*exp(states[0]/80.0); + algebraic[1] = constants[1]*(states[0]-computedConstants[0]); + algebraic[5] = externalVariable(voi, states, rates, variables, 5); + algebraic[3] = algebraic[5]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[7] = 4.0*exp(states[0]/18.0); + algebraic[8] = 0.07*exp(states[0]/20.0); + algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[11] = 0.125*exp(states[0]/80.0); algebraic[4] = externalVariable(voi, states, rates, variables, 4); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index e518a203f..fb7c5c7ff 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -74,51 +74,51 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - constants[5] = 0.0 - constants[7] = 0.3 - constants[15] = 36.0 + constants[0] = 0.0 + constants[1] = 0.3 + constants[2] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 - algebraic[9] = external_variable(voi, states, rates, variables, 9) + algebraic[5] = external_variable(voi, states, rates, variables, 5) algebraic[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): - computed_constants[6] = constants[5]-10.613 - computed_constants[8] = constants[5]-115.0 - computed_constants[14] = constants[5]+12.0 + computed_constants[0] = constants[0]-10.613 + computed_constants[1] = constants[0]-115.0 + computed_constants[2] = constants[0]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[9] = external_variable(voi, states, rates, variables, 9) + algebraic[5] = external_variable(voi, states, rates, variables, 5) algebraic[4] = external_variable(voi, states, rates, variables, 4) - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[3] = algebraic[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) + algebraic[1] = constants[1]*(states[0]-computed_constants[0]) + algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[3] = algebraic[5]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4] - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] + algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[7] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2] + algebraic[8] = 0.07*exp(states[0]/20.0) + algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1] + algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[11] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[9] = external_variable(voi, states, rates, variables, 9) - algebraic[3] = algebraic[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) + algebraic[1] = constants[1]*(states[0]-computed_constants[0]) + algebraic[5] = external_variable(voi, states, rates, variables, 5) + algebraic[3] = algebraic[5]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[7] = 4.0*exp(states[0]/18.0) + algebraic[8] = 0.07*exp(states[0]/20.0) + algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[11] = 0.125*exp(states[0]/80.0) algebraic[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index a8baed030..daca5bba8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -72,43 +72,43 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - constants[5] = 1.0; - constants[6] = 0.0; - constants[8] = 0.3; - constants[10] = 120.0; - constants[17] = 36.0; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; states[0] = 0.6; states[1] = 0.325; algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[11] = externalVariable(voi, states, rates, variables, 11); + algebraic[5] = externalVariable(voi, states, rates, variables, 5); } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[7] = constants[6]-10.613; - computedConstants[9] = constants[6]-115.0; - computedConstants[16] = constants[6]+12.0; + computedConstants[0] = constants[1]-10.613; + computedConstants[1] = constants[1]-115.0; + computedConstants[2] = constants[1]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[14] = 0.07*exp(algebraic[1]/20.0); - algebraic[15] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0); - rates[0] = algebraic[14]*(1.0-states[0])-algebraic[15]*states[0]; - algebraic[18] = 0.01*(algebraic[1]+10.0)/(exp((algebraic[1]+10.0)/10.0)-1.0); - algebraic[19] = 0.125*exp(algebraic[1]/80.0); - rates[1] = algebraic[18]*(1.0-states[1])-algebraic[19]*states[1]; + algebraic[8] = 0.07*exp(algebraic[1]/20.0); + algebraic[9] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0); + rates[0] = algebraic[8]*(1.0-states[0])-algebraic[9]*states[0]; + algebraic[10] = 0.01*(algebraic[1]+10.0)/(exp((algebraic[1]+10.0)/10.0)-1.0); + algebraic[11] = 0.125*exp(algebraic[1]/80.0); + rates[1] = algebraic[10]*(1.0-states[1])-algebraic[11]*states[1]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[2] = constants[8]*(algebraic[1]-computedConstants[7]); - algebraic[11] = externalVariable(voi, states, rates, variables, 11); - algebraic[4] = constants[10]*pow(algebraic[11], 3.0)*states[0]*(algebraic[1]-computedConstants[9]); - algebraic[12] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0); - algebraic[13] = 4.0*exp(algebraic[1]/18.0); - algebraic[3] = constants[17]*pow(states[1], 4.0)*(algebraic[1]-computedConstants[16]); + algebraic[2] = constants[2]*(algebraic[1]-computedConstants[0]); + algebraic[5] = externalVariable(voi, states, rates, variables, 5); + algebraic[4] = constants[3]*pow(algebraic[5], 3.0)*states[0]*(algebraic[1]-computedConstants[1]); + algebraic[6] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0); + algebraic[7] = 4.0*exp(algebraic[1]/18.0); + algebraic[3] = constants[4]*pow(states[1], 4.0)*(algebraic[1]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 914194e7f..02be0961d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -74,39 +74,39 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - constants[5] = 1.0 - constants[6] = 0.0 - constants[8] = 0.3 - constants[10] = 120.0 - constants[17] = 36.0 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 states[0] = 0.6 states[1] = 0.325 algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[11] = external_variable(voi, states, rates, variables, 11) + algebraic[5] = external_variable(voi, states, rates, variables, 5) def compute_computed_constants(constants, computed_constants): - computed_constants[7] = constants[6]-10.613 - computed_constants[9] = constants[6]-115.0 - computed_constants[16] = constants[6]+12.0 + computed_constants[0] = constants[1]-10.613 + computed_constants[1] = constants[1]-115.0 + computed_constants[2] = constants[1]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[14] = 0.07*exp(algebraic[1]/20.0) - algebraic[15] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0) - rates[0] = algebraic[14]*(1.0-states[0])-algebraic[15]*states[0] - algebraic[18] = 0.01*(algebraic[1]+10.0)/(exp((algebraic[1]+10.0)/10.0)-1.0) - algebraic[19] = 0.125*exp(algebraic[1]/80.0) - rates[1] = algebraic[18]*(1.0-states[1])-algebraic[19]*states[1] + algebraic[8] = 0.07*exp(algebraic[1]/20.0) + algebraic[9] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0) + rates[0] = algebraic[8]*(1.0-states[0])-algebraic[9]*states[0] + algebraic[10] = 0.01*(algebraic[1]+10.0)/(exp((algebraic[1]+10.0)/10.0)-1.0) + algebraic[11] = 0.125*exp(algebraic[1]/80.0) + rates[1] = algebraic[10]*(1.0-states[1])-algebraic[11]*states[1] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[2] = constants[8]*(algebraic[1]-computed_constants[7]) - algebraic[11] = external_variable(voi, states, rates, variables, 11) - algebraic[4] = constants[10]*pow(algebraic[11], 3.0)*states[0]*(algebraic[1]-computed_constants[9]) - algebraic[12] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0) - algebraic[13] = 4.0*exp(algebraic[1]/18.0) - algebraic[3] = constants[17]*pow(states[1], 4.0)*(algebraic[1]-computed_constants[16]) + algebraic[2] = constants[2]*(algebraic[1]-computed_constants[0]) + algebraic[5] = external_variable(voi, states, rates, variables, 5) + algebraic[4] = constants[3]*pow(algebraic[5], 3.0)*states[0]*(algebraic[1]-computed_constants[1]) + algebraic[6] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0) + algebraic[7] = 4.0*exp(algebraic[1]/18.0) + algebraic[3] = constants[4]*pow(states[1], 4.0)*(algebraic[1]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index b21ab1d04..6daaf81cf 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -72,46 +72,46 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - constants[5] = 1.0; - constants[6] = 0.0; - constants[8] = 0.3; - constants[10] = 120.0; - constants[16] = 36.0; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; states[0] = 0.6; states[1] = 0.05; states[2] = 0.325; algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[17] = externalVariable(voi, states, rates, variables, 17); + algebraic[9] = externalVariable(voi, states, rates, variables, 9); algebraic[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[7] = constants[6]-10.613; - computedConstants[9] = constants[6]-115.0; - computedConstants[15] = constants[6]+12.0; + computedConstants[0] = constants[1]-10.613; + computedConstants[1] = constants[1]-115.0; + computedConstants[2] = constants[1]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[11] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0); - algebraic[12] = 4.0*exp(algebraic[1]/18.0); - rates[1] = algebraic[11]*(1.0-states[1])-algebraic[12]*states[1]; - algebraic[13] = 0.07*exp(algebraic[1]/20.0); - algebraic[14] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0); - rates[0] = algebraic[13]*(1.0-states[0])-algebraic[14]*states[0]; - algebraic[17] = externalVariable(voi, states, rates, variables, 17); - algebraic[18] = 0.125*exp(algebraic[1]/80.0); - rates[2] = algebraic[17]*(1.0-states[2])-algebraic[18]*states[2]; + algebraic[5] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0); + algebraic[6] = 4.0*exp(algebraic[1]/18.0); + rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1]; + algebraic[7] = 0.07*exp(algebraic[1]/20.0); + algebraic[8] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0); + rates[0] = algebraic[7]*(1.0-states[0])-algebraic[8]*states[0]; + algebraic[9] = externalVariable(voi, states, rates, variables, 9); + algebraic[10] = 0.125*exp(algebraic[1]/80.0); + rates[2] = algebraic[9]*(1.0-states[2])-algebraic[10]*states[2]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[2] = constants[8]*(algebraic[1]-computedConstants[7]); - algebraic[17] = externalVariable(voi, states, rates, variables, 17); + algebraic[2] = constants[2]*(algebraic[1]-computedConstants[0]); + algebraic[9] = externalVariable(voi, states, rates, variables, 9); algebraic[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[3] = constants[16]*pow(states[2], 4.0)*(algebraic[1]-computedConstants[15]); + algebraic[3] = constants[4]*pow(states[2], 4.0)*(algebraic[1]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index d64291b4a..0cbe773e1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -74,42 +74,42 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - constants[5] = 1.0 - constants[6] = 0.0 - constants[8] = 0.3 - constants[10] = 120.0 - constants[16] = 36.0 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 states[0] = 0.6 states[1] = 0.05 states[2] = 0.325 algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[17] = external_variable(voi, states, rates, variables, 17) + algebraic[9] = external_variable(voi, states, rates, variables, 9) algebraic[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): - computed_constants[7] = constants[6]-10.613 - computed_constants[9] = constants[6]-115.0 - computed_constants[15] = constants[6]+12.0 + computed_constants[0] = constants[1]-10.613 + computed_constants[1] = constants[1]-115.0 + computed_constants[2] = constants[1]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[11] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0) - algebraic[12] = 4.0*exp(algebraic[1]/18.0) - rates[1] = algebraic[11]*(1.0-states[1])-algebraic[12]*states[1] - algebraic[13] = 0.07*exp(algebraic[1]/20.0) - algebraic[14] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0) - rates[0] = algebraic[13]*(1.0-states[0])-algebraic[14]*states[0] - algebraic[17] = external_variable(voi, states, rates, variables, 17) - algebraic[18] = 0.125*exp(algebraic[1]/80.0) - rates[2] = algebraic[17]*(1.0-states[2])-algebraic[18]*states[2] + algebraic[5] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0) + algebraic[6] = 4.0*exp(algebraic[1]/18.0) + rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1] + algebraic[7] = 0.07*exp(algebraic[1]/20.0) + algebraic[8] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0) + rates[0] = algebraic[7]*(1.0-states[0])-algebraic[8]*states[0] + algebraic[9] = external_variable(voi, states, rates, variables, 9) + algebraic[10] = 0.125*exp(algebraic[1]/80.0) + rates[2] = algebraic[9]*(1.0-states[2])-algebraic[10]*states[2] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[2] = constants[8]*(algebraic[1]-computed_constants[7]) - algebraic[17] = external_variable(voi, states, rates, variables, 17) + algebraic[2] = constants[2]*(algebraic[1]-computed_constants[0]) + algebraic[9] = external_variable(voi, states, rates, variables, 9) algebraic[4] = external_variable(voi, states, rates, variables, 4) - algebraic[3] = constants[16]*pow(states[2], 4.0)*(algebraic[1]-computed_constants[15]) + algebraic[3] = constants[4]*pow(states[2], 4.0)*(algebraic[1]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 87eb31f08..68e90fdd0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -73,11 +73,11 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - constants[4] = 1.0 - constants[5] = 0.0 - constants[7] = 0.3 - constants[9] = 120.0 - constants[15] = 36.0 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -85,35 +85,35 @@ def initialise_variables(states, rates, constants): def compute_computed_constants(constants, computed_constants): - computed_constants[6] = constants[5]-10.613 - computed_constants[8] = constants[5]-115.0 - computed_constants[14] = constants[5]+12.0 + computed_constants[0] = constants[1]-10.613 + computed_constants[1] = constants[1]-115.0 + computed_constants[2] = constants[1]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[10]*(1.0-states[2])-algebraic[11]*states[2] - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[12]*(1.0-states[1])-algebraic[13]*states[1] - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) - rates[3] = algebraic[16]*(1.0-states[3])-algebraic[17]*states[3] + algebraic[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[3] = constants[9]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[8]) - algebraic[10] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[11] = 4.0*exp(states[0]/18.0) - algebraic[12] = 0.07*exp(states[0]/20.0) - algebraic[13] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[15]*pow(states[3], 4.0)*(states[0]-computed_constants[14]) - algebraic[16] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[17] = 0.125*exp(states[0]/80.0) + algebraic[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 083b39125..fa7028471 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -72,50 +72,50 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) { - constants[4] = 1.0; - constants[5] = 0.0; - constants[7] = 0.3; - constants[9] = 120.0; - constants[16] = 36.0; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.325; - algebraic[10] = externalVariable(voi, states, rates, variables, 10); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[6] = constants[5]-10.613; - computedConstants[8] = constants[5]-115.0; - computedConstants[15] = constants[5]+12.0; + computedConstants[0] = constants[1]-10.613; + computedConstants[1] = constants[1]-115.0; + computedConstants[2] = constants[1]+12.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[2] = constants[16]*pow(states[2], 4.0)*(states[0]-computedConstants[15]); - algebraic[10] = externalVariable(voi, states, rates, variables, 10); - algebraic[3] = constants[9]*pow(algebraic[10], 3.0)*states[1]*(states[0]-computedConstants[8]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4]; - algebraic[13] = 0.07*exp(states[0]/20.0); - algebraic[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[13]*(1.0-states[1])-algebraic[14]*states[1]; - algebraic[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[18] = 0.125*exp(states[0]/80.0); - rates[2] = algebraic[17]*(1.0-states[2])-algebraic[18]*states[2]; + algebraic[1] = constants[2]*(states[0]-computedConstants[0]); + algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[3] = constants[3]*pow(algebraic[4], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; + algebraic[7] = 0.07*exp(states[0]/20.0); + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1]; + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[10] = 0.125*exp(states[0]/80.0); + rates[2] = algebraic[9]*(1.0-states[2])-algebraic[10]*states[2]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[1] = constants[7]*(states[0]-computedConstants[6]); - algebraic[10] = externalVariable(voi, states, rates, variables, 10); - algebraic[3] = constants[9]*pow(algebraic[10], 3.0)*states[1]*(states[0]-computedConstants[8]); - algebraic[11] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[12] = 4.0*exp(states[0]/18.0); - algebraic[13] = 0.07*exp(states[0]/20.0); - algebraic[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[16]*pow(states[2], 4.0)*(states[0]-computedConstants[15]); - algebraic[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[18] = 0.125*exp(states[0]/80.0); + algebraic[1] = constants[2]*(states[0]-computedConstants[0]); + algebraic[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[3] = constants[3]*pow(algebraic[4], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[6] = 4.0*exp(states[0]/18.0); + algebraic[7] = 0.07*exp(states[0]/20.0); + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[10] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index bee8d59e4..d1748c002 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -74,46 +74,46 @@ def create_variables_array(): def initialise_variables(voi, states, rates, constants, external_variable): - constants[4] = 1.0 - constants[5] = 0.0 - constants[7] = 0.3 - constants[9] = 120.0 - constants[16] = 36.0 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.325 - algebraic[10] = external_variable(voi, states, rates, variables, 10) + algebraic[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): - computed_constants[6] = constants[5]-10.613 - computed_constants[8] = constants[5]-115.0 - computed_constants[15] = constants[5]+12.0 + computed_constants[0] = constants[1]-10.613 + computed_constants[1] = constants[1]-115.0 + computed_constants[2] = constants[1]+12.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[2] = constants[16]*pow(states[2], 4.0)*(states[0]-computed_constants[15]) - algebraic[10] = external_variable(voi, states, rates, variables, 10) - algebraic[3] = constants[9]*pow(algebraic[10], 3.0)*states[1]*(states[0]-computed_constants[8]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[4] - algebraic[13] = 0.07*exp(states[0]/20.0) - algebraic[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[13]*(1.0-states[1])-algebraic[14]*states[1] - algebraic[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[18] = 0.125*exp(states[0]/80.0) - rates[2] = algebraic[17]*(1.0-states[2])-algebraic[18]*states[2] + algebraic[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) + algebraic[4] = external_variable(voi, states, rates, variables, 4) + algebraic[3] = constants[3]*pow(algebraic[4], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] + algebraic[7] = 0.07*exp(states[0]/20.0) + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1] + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[10] = 0.125*exp(states[0]/80.0) + rates[2] = algebraic[9]*(1.0-states[2])-algebraic[10]*states[2] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[1] = constants[7]*(states[0]-computed_constants[6]) - algebraic[10] = external_variable(voi, states, rates, variables, 10) - algebraic[3] = constants[9]*pow(algebraic[10], 3.0)*states[1]*(states[0]-computed_constants[8]) - algebraic[11] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[12] = 4.0*exp(states[0]/18.0) - algebraic[13] = 0.07*exp(states[0]/20.0) - algebraic[14] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[16]*pow(states[2], 4.0)*(states[0]-computed_constants[15]) - algebraic[17] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[18] = 0.125*exp(states[0]/80.0) + algebraic[1] = constants[2]*(states[0]-computed_constants[0]) + algebraic[4] = external_variable(voi, states, rates, variables, 4) + algebraic[3] = constants[3]*pow(algebraic[4], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[6] = 4.0*exp(states[0]/18.0) + algebraic[7] = 0.07*exp(states[0]/20.0) + algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) + algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[10] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index e8a180474..d0434bbc6 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -71,11 +71,11 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - constants[3] = 12.0; - constants[4] = 0.075; - constants[5] = -60.0; - constants[7] = 400.0; - constants[8] = 40.0; + constants[0] = 12.0; + constants[1] = 0.075; + constants[2] = -60.0; + constants[3] = 400.0; + constants[4] = 40.0; states[0] = -87.0; states[1] = 0.01; states[2] = 0.8; @@ -88,36 +88,36 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[6] = pow(states[1], 3.0)*states[2]*constants[7]; - algebraic[0] = (algebraic[6]+0.14)*(states[0]-constants[8]); - algebraic[1] = constants[4]*(states[0]-constants[5]); - algebraic[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); - algebraic[14] = 1.2*pow(states[3], 4.0); - algebraic[2] = (algebraic[13]+algebraic[14])*(states[0]+100.0); - rates[0] = -(algebraic[0]+algebraic[2]+algebraic[1])/constants[3]; - algebraic[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); - algebraic[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); - rates[1] = algebraic[9]*(1.0-states[1])-algebraic[10]*states[1]; - algebraic[11] = 0.17*exp((-states[0]-90.0)/20.0); - algebraic[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); - rates[2] = algebraic[11]*(1.0-states[2])-algebraic[12]*states[2]; - algebraic[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); - algebraic[16] = 0.002*exp((-states[0]-90.0)/80.0); - rates[3] = algebraic[15]*(1.0-states[3])-algebraic[16]*states[3]; + algebraic[3] = pow(states[1], 3.0)*states[2]*constants[3]; + algebraic[0] = (algebraic[3]+0.14)*(states[0]-constants[4]); + algebraic[1] = constants[1]*(states[0]-constants[2]); + algebraic[8] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); + algebraic[9] = 1.2*pow(states[3], 4.0); + algebraic[2] = (algebraic[8]+algebraic[9])*(states[0]+100.0); + rates[0] = -(algebraic[0]+algebraic[2]+algebraic[1])/constants[0]; + algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); + algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); + rates[1] = algebraic[4]*(1.0-states[1])-algebraic[5]*states[1]; + algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0); + algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); + rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2]; + algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); + algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0); + rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[1] = constants[4]*(states[0]-constants[5]); - algebraic[6] = pow(states[1], 3.0)*states[2]*constants[7]; - algebraic[0] = (algebraic[6]+0.14)*(states[0]-constants[8]); - algebraic[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); - algebraic[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); - algebraic[11] = 0.17*exp((-states[0]-90.0)/20.0); - algebraic[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); - algebraic[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); - algebraic[14] = 1.2*pow(states[3], 4.0); - algebraic[2] = (algebraic[13]+algebraic[14])*(states[0]+100.0); - algebraic[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); - algebraic[16] = 0.002*exp((-states[0]-90.0)/80.0); + algebraic[1] = constants[1]*(states[0]-constants[2]); + algebraic[3] = pow(states[1], 3.0)*states[2]*constants[3]; + algebraic[0] = (algebraic[3]+0.14)*(states[0]-constants[4]); + algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); + algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); + algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0); + algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); + algebraic[8] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); + algebraic[9] = 1.2*pow(states[3], 4.0); + algebraic[2] = (algebraic[8]+algebraic[9])*(states[0]+100.0); + algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); + algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0); } diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index d9672b95f..04b3307a0 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -60,11 +60,11 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - constants[3] = 12.0 - constants[4] = 0.075 - constants[5] = -60.0 - constants[7] = 400.0 - constants[8] = 40.0 + constants[0] = 12.0 + constants[1] = 0.075 + constants[2] = -60.0 + constants[3] = 400.0 + constants[4] = 40.0 states[0] = -87.0 states[1] = 0.01 states[2] = 0.8 @@ -76,34 +76,34 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[6] = pow(states[1], 3.0)*states[2]*constants[7] - algebraic[0] = (algebraic[6]+0.14)*(states[0]-constants[8]) - algebraic[1] = constants[4]*(states[0]-constants[5]) - algebraic[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) - algebraic[14] = 1.2*pow(states[3], 4.0) - algebraic[2] = (algebraic[13]+algebraic[14])*(states[0]+100.0) - rates[0] = -(algebraic[0]+algebraic[2]+algebraic[1])/constants[3] - algebraic[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) - algebraic[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) - rates[1] = algebraic[9]*(1.0-states[1])-algebraic[10]*states[1] - algebraic[11] = 0.17*exp((-states[0]-90.0)/20.0) - algebraic[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) - rates[2] = algebraic[11]*(1.0-states[2])-algebraic[12]*states[2] - algebraic[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) - algebraic[16] = 0.002*exp((-states[0]-90.0)/80.0) - rates[3] = algebraic[15]*(1.0-states[3])-algebraic[16]*states[3] + algebraic[3] = pow(states[1], 3.0)*states[2]*constants[3] + algebraic[0] = (algebraic[3]+0.14)*(states[0]-constants[4]) + algebraic[1] = constants[1]*(states[0]-constants[2]) + algebraic[8] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) + algebraic[9] = 1.2*pow(states[3], 4.0) + algebraic[2] = (algebraic[8]+algebraic[9])*(states[0]+100.0) + rates[0] = -(algebraic[0]+algebraic[2]+algebraic[1])/constants[0] + algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) + algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) + rates[1] = algebraic[4]*(1.0-states[1])-algebraic[5]*states[1] + algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0) + algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) + rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2] + algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) + algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0) + rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = constants[4]*(states[0]-constants[5]) - algebraic[6] = pow(states[1], 3.0)*states[2]*constants[7] - algebraic[0] = (algebraic[6]+0.14)*(states[0]-constants[8]) - algebraic[9] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) - algebraic[10] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) - algebraic[11] = 0.17*exp((-states[0]-90.0)/20.0) - algebraic[12] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) - algebraic[13] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) - algebraic[14] = 1.2*pow(states[3], 4.0) - algebraic[2] = (algebraic[13]+algebraic[14])*(states[0]+100.0) - algebraic[15] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) - algebraic[16] = 0.002*exp((-states[0]-90.0)/80.0) + algebraic[1] = constants[1]*(states[0]-constants[2]) + algebraic[3] = pow(states[1], 3.0)*states[2]*constants[3] + algebraic[0] = (algebraic[3]+0.14)*(states[0]-constants[4]) + algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) + algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) + algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0) + algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) + algebraic[8] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) + algebraic[9] = 1.2*pow(states[3], 4.0) + algebraic[2] = (algebraic[8]+algebraic[9])*(states[0]+100.0) + algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) + algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0) diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index d25ae1df3..90bfcb513 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -72,9 +72,9 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[2] = u[0]; + algebraic[0] = u[0]; - f[0] = 1.0-(states[0]+states[1]+algebraic[2]); + f[0] = 1.0-(states[0]+states[1]+algebraic[0]); } void findRoot0(double voi, double *states, double *rates, double *variables) @@ -82,19 +82,19 @@ void findRoot0(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[2]; + u[0] = algebraic[0]; nlaSolve(objectiveFunction0, u, 1, &rfi); - algebraic[2] = u[0]; + algebraic[0] = u[0]; } void initialiseVariables(double *states, double *rates, double *constants) { constants[0] = 0.04; constants[1] = 1.0e4; - algebraic[2] = 0.0; - constants[3] = 3.0e7; + algebraic[0] = 0.0; + constants[2] = 3.0e7; states[0] = 1.0; states[1] = 0.0; } @@ -106,12 +106,12 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, variables); - rates[0] = -constants[0]*states[0]+constants[1]*states[1]*algebraic[2]; - rates[1] = constants[0]*states[0]-constants[3]*pow(states[1], 2.0)-constants[1]*states[1]*algebraic[2]; + rates[0] = -constants[0]*states[0]+constants[1]*states[1]*algebraic[0]; + rates[1] = constants[0]*states[0]-constants[2]*pow(states[1], 2.0)-constants[1]*states[1]*algebraic[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, variables); - algebraic[4] = 10000.0*states[1]; + algebraic[1] = 10000.0*states[1]; } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index a01a61531..034f6a13c 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -54,26 +54,26 @@ def objective_function_0(u, f, data): rates = data[2] variables = data[3] - algebraic[2] = u[0] + algebraic[0] = u[0] - f[0] = 1.0-(states[0]+states[1]+algebraic[2]) + f[0] = 1.0-(states[0]+states[1]+algebraic[0]) def find_root_0(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[2] + u[0] = algebraic[0] u = nla_solve(objective_function_0, u, 1, [voi, states, rates, variables]) - algebraic[2] = u[0] + algebraic[0] = u[0] def initialise_variables(states, rates, constants): constants[0] = 0.04 constants[1] = 1.0e4 - algebraic[2] = 0.0 - constants[3] = 3.0e7 + algebraic[0] = 0.0 + constants[2] = 3.0e7 states[0] = 1.0 states[1] = 0.0 @@ -84,10 +84,10 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, variables) - rates[0] = -constants[0]*states[0]+constants[1]*states[1]*algebraic[2] - rates[1] = constants[0]*states[0]-constants[3]*pow(states[1], 2.0)-constants[1]*states[1]*algebraic[2] + rates[0] = -constants[0]*states[0]+constants[1]*states[1]*algebraic[0] + rates[1] = constants[0]*states[0]-constants[2]*pow(states[1], 2.0)-constants[1]*states[1]*algebraic[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, variables) - algebraic[4] = 10000.0*states[1] + algebraic[1] = 10000.0*states[1] diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index c513ea1bd..51c94697b 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -78,5 +78,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[3] = 10000.0*states[2]; + algebraic[0] = 10000.0*states[2]; } diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 5724071fc..f702e804d 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -65,4 +65,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[3] = 10000.0*states[2] + algebraic[0] = 10000.0*states[2] diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 6dfb92f02..0f52edcd5 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -61,14 +61,14 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants) { - constants[1] = 0.0; - constants[3] = 0.75; - computedConstants[4] = 2.0/3.14159265358979; - computedConstants[5] = 2.0*3.14159265358979; - computedConstants[6] = 3.14159265358979/2.0; - computedConstants[7] = 3.14159265358979; - computedConstants[8] = 3.0*3.14159265358979/2.0; - states[0] = constants[1]; + constants[0] = 0.0; + constants[1] = 0.75; + computedConstants[0] = 2.0/3.14159265358979; + computedConstants[1] = 2.0*3.14159265358979; + computedConstants[2] = 3.14159265358979/2.0; + computedConstants[3] = 3.14159265358979; + computedConstants[4] = 3.0*3.14159265358979/2.0; + states[0] = constants[0]; } void computeComputedConstants(double *constants, double *computedConstants) @@ -83,6 +83,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { algebraic[0] = sin(voi); - algebraic[9] = (voi < computedConstants[6])?voi*computedConstants[4]-0.5:(voi < computedConstants[7])?(3.14159265358979-voi)*computedConstants[4]-0.5:(voi < computedConstants[8])?(voi-3.14159265358979)*computedConstants[4]-0.5:(computedConstants[5]-voi)*computedConstants[4]-0.5; - algebraic[2] = (voi < computedConstants[6])?-algebraic[9]*algebraic[9]+constants[3]+algebraic[9]:(voi < computedConstants[7])?-algebraic[9]*algebraic[9]+constants[3]+algebraic[9]:(voi < computedConstants[8])?algebraic[9]*algebraic[9]-constants[3]-algebraic[9]:algebraic[9]*algebraic[9]-constants[3]-algebraic[9]; + algebraic[2] = (voi < computedConstants[2])?voi*computedConstants[0]-0.5:(voi < computedConstants[3])?(3.14159265358979-voi)*computedConstants[0]-0.5:(voi < computedConstants[4])?(voi-3.14159265358979)*computedConstants[0]-0.5:(computedConstants[1]-voi)*computedConstants[0]-0.5; + algebraic[1] = (voi < computedConstants[2])?-algebraic[2]*algebraic[2]+constants[1]+algebraic[2]:(voi < computedConstants[3])?-algebraic[2]*algebraic[2]+constants[1]+algebraic[2]:(voi < computedConstants[4])?algebraic[2]*algebraic[2]-constants[1]-algebraic[2]:algebraic[2]*algebraic[2]-constants[1]-algebraic[2]; } diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 2c2c46397..065f85ab7 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -54,14 +54,14 @@ def create_variables_array(): def initialise_variables(states, rates, constants): - constants[1] = 0.0 - constants[3] = 0.75 - computed_constants[4] = 2.0/3.14159265358979 - computed_constants[5] = 2.0*3.14159265358979 - computed_constants[6] = 3.14159265358979/2.0 - computed_constants[7] = 3.14159265358979 - computed_constants[8] = 3.0*3.14159265358979/2.0 - states[0] = constants[1] + constants[0] = 0.0 + constants[1] = 0.75 + computed_constants[0] = 2.0/3.14159265358979 + computed_constants[1] = 2.0*3.14159265358979 + computed_constants[2] = 3.14159265358979/2.0 + computed_constants[3] = 3.14159265358979 + computed_constants[4] = 3.0*3.14159265358979/2.0 + states[0] = constants[0] def compute_computed_constants(constants, computed_constants): @@ -74,5 +74,5 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): algebraic[0] = sin(voi) - algebraic[9] = voi*computed_constants[4]-0.5 if lt_func(voi, computed_constants[6]) else (3.14159265358979-voi)*computed_constants[4]-0.5 if lt_func(voi, computed_constants[7]) else (voi-3.14159265358979)*computed_constants[4]-0.5 if lt_func(voi, computed_constants[8]) else (computed_constants[5]-voi)*computed_constants[4]-0.5 - algebraic[2] = -algebraic[9]*algebraic[9]+constants[3]+algebraic[9] if lt_func(voi, computed_constants[6]) else -algebraic[9]*algebraic[9]+constants[3]+algebraic[9] if lt_func(voi, computed_constants[7]) else algebraic[9]*algebraic[9]-constants[3]-algebraic[9] if lt_func(voi, computed_constants[8]) else algebraic[9]*algebraic[9]-constants[3]-algebraic[9] + algebraic[2] = voi*computed_constants[0]-0.5 if lt_func(voi, computed_constants[2]) else (3.14159265358979-voi)*computed_constants[0]-0.5 if lt_func(voi, computed_constants[3]) else (voi-3.14159265358979)*computed_constants[0]-0.5 if lt_func(voi, computed_constants[4]) else (computed_constants[1]-voi)*computed_constants[0]-0.5 + algebraic[1] = -algebraic[2]*algebraic[2]+constants[1]+algebraic[2] if lt_func(voi, computed_constants[2]) else -algebraic[2]*algebraic[2]+constants[1]+algebraic[2] if lt_func(voi, computed_constants[3]) else algebraic[2]*algebraic[2]-constants[1]-algebraic[2] if lt_func(voi, computed_constants[4]) else algebraic[2]*algebraic[2]-constants[1]-algebraic[2] diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 8167206cd..db7744dbb 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -43,15 +43,15 @@ void deleteArray(double *array) void initialiseVariables(double *constants, ExternalVariable externalVariable) { - constants[1] = 1.1; - constants[2] = 21262500.0; - constants[3] = 150.0; - constants[4] = 3402000.0; - constants[5] = 2.0; - constants[6] = 2902500.0; - constants[7] = 810000.0; - constants[8] = 247140.0; - algebraic[9] = externalVariable(variables, 9); + constants[0] = 1.1; + constants[1] = 21262500.0; + constants[2] = 150.0; + constants[3] = 3402000.0; + constants[4] = 2.0; + constants[5] = 2902500.0; + constants[6] = 810000.0; + constants[7] = 247140.0; + algebraic[1] = externalVariable(variables, 1); } void computeComputedConstants(double *constants, double *computedConstants) @@ -60,6 +60,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[9] = externalVariable(variables, 9); - algebraic[0] = constants[1]*(constants[2]*constants[3]-constants[4]*constants[5])/(constants[6]*constants[5]+algebraic[9]*constants[3]+constants[8]*constants[5]*constants[3]+constants[7]); + algebraic[1] = externalVariable(variables, 1); + algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+algebraic[1]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]); } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 3c5f0470c..f07ad2cca 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -38,15 +38,15 @@ def create_variables_array(): def initialise_variables(constants, external_variable): - constants[1] = 1.1 - constants[2] = 21262500.0 - constants[3] = 150.0 - constants[4] = 3402000.0 - constants[5] = 2.0 - constants[6] = 2902500.0 - constants[7] = 810000.0 - constants[8] = 247140.0 - algebraic[9] = external_variable(variables, 9) + constants[0] = 1.1 + constants[1] = 21262500.0 + constants[2] = 150.0 + constants[3] = 3402000.0 + constants[4] = 2.0 + constants[5] = 2902500.0 + constants[6] = 810000.0 + constants[7] = 247140.0 + algebraic[1] = external_variable(variables, 1) def compute_computed_constants(constants, computed_constants): @@ -54,5 +54,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - algebraic[9] = external_variable(variables, 9) - algebraic[0] = constants[1]*(constants[2]*constants[3]-constants[4]*constants[5])/(constants[6]*constants[5]+algebraic[9]*constants[3]+constants[8]*constants[5]*constants[3]+constants[7]) + algebraic[1] = external_variable(variables, 1) + algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+algebraic[1]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) From 09fcc1fb41e25663e46ab7ef60c4674a23e6c731 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 8 Aug 2024 13:23:05 +0200 Subject: [PATCH 12/74] Some minor cleaning up. --- src/generator.cpp | 48 +++++++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index 553234430..f6130eb74 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -514,9 +514,8 @@ void Generator::GeneratorImpl::addImplementationVariableInfoCode() && !mProfile->algebraicVariableTypeString().empty() && !mProfile->externalVariableTypeString().empty()) { std::string infoElementsCode; - auto variables = libcellml::variables(mModel); - for (const auto &variable : variables) { + for (const auto &variable : variables(mModel)) { if (!infoElementsCode.empty()) { infoElementsCode += mProfile->arrayElementSeparatorString() + "\n"; } @@ -805,21 +804,20 @@ void Generator::GeneratorImpl::addNlaSystemsCode() std::string methodBody; auto i = MAX_SIZE_T; auto variables = libcellml::variables(equation); - auto variablesCount = variables.size(); - for (i = 0; i < variablesCount; ++i) { - auto arrayString = (variables[i]->type() == AnalyserVariable::Type::STATE) ? + for (const auto &variable : variables) { + auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - (variables[i]->type() == AnalyserVariable::Type::CONSTANT) ? + (variable->type() == AnalyserVariable::Type::CONSTANT) ? mProfile->constantsArrayString() : - (variables[i]->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) ? + (variable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) ? mProfile->computedConstantsArrayString() : mProfile->algebraicArrayString(); methodBody += mProfile->indentString() - + arrayString + mProfile->openArrayString() + convertToString(variables[i]->index()) + mProfile->closeArrayString() + + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() + mProfile->equalityString() - + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(i) + mProfile->closeArrayString() + + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() + mProfile->commandSeparatorString() + "\n"; } @@ -852,18 +850,22 @@ void Generator::GeneratorImpl::addNlaSystemsCode() methodBody = {}; - for (i = 0; i < variablesCount; ++i) { - auto arrayString = (variables[i]->type() == AnalyserVariable::Type::STATE) ? + i = MAX_SIZE_T; + + for (const auto &variable : variables) { + auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : mProfile->algebraicArrayString(); methodBody += mProfile->indentString() - + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(i) + mProfile->closeArrayString() + + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() + mProfile->equalityString() - + arrayString + mProfile->openArrayString() + convertToString(variables[i]->index()) + mProfile->closeArrayString() + + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() + mProfile->commandSeparatorString() + "\n"; } + auto variablesCount = variables.size(); + methodBody += newLineIfNeeded() + mProfile->indentString() + replace(replace(mProfile->nlaSolveCallString(modelHasOdes()), @@ -872,15 +874,17 @@ void Generator::GeneratorImpl::addNlaSystemsCode() methodBody += newLineIfNeeded(); - for (i = 0; i < variablesCount; ++i) { - auto arrayString = (variables[i]->type() == AnalyserVariable::Type::STATE) ? + i = MAX_SIZE_T; + + for (const auto &variable : variables) { + auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : mProfile->algebraicArrayString(); methodBody += mProfile->indentString() - + arrayString + mProfile->openArrayString() + convertToString(variables[i]->index()) + mProfile->closeArrayString() + + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() + mProfile->equalityString() - + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(i) + mProfile->closeArrayString() + + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() + mProfile->commandSeparatorString() + "\n"; } @@ -1772,11 +1776,9 @@ std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquatio // Generate the equation code itself, based on the equation type. - auto variables = libcellml::variables(equation); - switch (equation->type()) { case AnalyserEquation::Type::EXTERNAL: - for (const auto &variable : variables) { + for (const auto &variable : variables(equation)) { res += mProfile->indentString() + generateVariableNameCode(variable->variable()) + mProfile->equalityString() @@ -1864,9 +1866,8 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st // such an NLA system has only one solution. std::string methodBody; - auto variables = libcellml::variables(mModel); - for (const auto &variable : variables) { + for (const auto &variable : variables(mModel)) { switch (variable->type()) { case AnalyserVariable::Type::CONSTANT: methodBody += generateInitialisationCode(variable); @@ -1963,11 +1964,10 @@ void Generator::GeneratorImpl::addImplementationComputeRatesMethodCode(std::vect // or RHS of the equation. auto variables = libcellml::variables(equation); - auto variablesCount = variables.size(); if ((equation->type() == AnalyserEquation::Type::ODE) || ((equation->type() == AnalyserEquation::Type::NLA) - && (variablesCount == 1) + && (variables.size() == 1) && (variables[0]->type() == AnalyserVariable::Type::STATE))) { methodBody += generateEquationCode(equation, remainingEquations); } From a7c7774d1e256a71ded87c495adb1034602bd7d8 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 8 Aug 2024 14:27:24 +0200 Subject: [PATCH 13/74] Generator: added an external array. --- src/analyser.cpp | 3 +- src/analyserequation.cpp | 29 ++++++++++- src/analyserequation_p.h | 4 +- src/analysermodel.cpp | 27 +++++++++++ src/analysermodel_p.h | 1 + src/api/libcellml/analyserequation.h | 29 +++++++++++ src/api/libcellml/analysermodel.h | 30 ++++++++++++ src/api/libcellml/generatorprofile.h | 48 +++++++++++++++++++ src/bindings/interface/analyserequation.i | 9 ++++ src/bindings/interface/analysermodel.i | 9 ++++ src/bindings/interface/generatorprofile.i | 13 +++++ src/bindings/javascript/analyserequation.cpp | 3 ++ src/bindings/javascript/analysermodel.cpp | 3 ++ src/bindings/javascript/generatorprofile.cpp | 4 ++ src/generator.cpp | 8 ++++ src/generatorprofile.cpp | 29 +++++++++++ src/generatorprofilesha1values.h | 4 +- src/generatorprofiletools.cpp | 3 ++ .../javascript/analyserequation.test.js | 9 ++++ .../javascript/generatorprofile.test.js | 12 +++++ tests/bindings/python/test_analyser.py | 3 ++ .../bindings/python/test_generator_profile.py | 18 +++++++ tests/coverage/coverage.cpp | 20 ++++++++ tests/generator/generatorprofile.cpp | 9 ++++ tests/resources/coverage/generator/model.c | 1 + tests/resources/coverage/generator/model.h | 1 + .../generator/model.modified.profile.c | 1 + .../generator/model.modified.profile.h | 1 + .../generator/model.modified.profile.py | 1 + tests/resources/coverage/generator/model.py | 1 + .../algebraic_eqn_computed_var_on_rhs/model.c | 1 + .../model.external.c | 1 + .../model.external.h | 1 + .../model.external.py | 1 + .../algebraic_eqn_computed_var_on_rhs/model.h | 1 + .../model.py | 1 + .../algebraic_eqn_const_var_on_rhs/model.c | 1 + .../algebraic_eqn_const_var_on_rhs/model.h | 1 + .../algebraic_eqn_const_var_on_rhs/model.py | 1 + .../algebraic_eqn_constant_on_rhs/model.c | 1 + .../algebraic_eqn_constant_on_rhs/model.h | 1 + .../algebraic_eqn_constant_on_rhs/model.py | 1 + .../algebraic_eqn_derivative_on_rhs/model.c | 1 + .../algebraic_eqn_derivative_on_rhs/model.h | 1 + .../algebraic_eqn_derivative_on_rhs/model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../algebraic_eqn_state_var_on_rhs/model.c | 1 + .../algebraic_eqn_state_var_on_rhs/model.h | 1 + .../algebraic_eqn_state_var_on_rhs/model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../model.c | 1 + .../model.external.c | 1 + .../model.external.h | 1 + .../model.external.py | 1 + .../model.h | 1 + .../model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../model.three.externals.c | 1 + .../model.three.externals.h | 1 + .../model.three.externals.py | 1 + .../model.not.ordered.c | 1 + .../model.not.ordered.h | 1 + .../model.not.ordered.py | 1 + .../model.ordered.c | 1 + .../model.ordered.h | 1 + .../model.ordered.py | 1 + .../algebraic_unknown_var_on_rhs/model.c | 1 + .../algebraic_unknown_var_on_rhs/model.h | 1 + .../algebraic_unknown_var_on_rhs/model.py | 1 + .../generator/cell_geometry_model/model.c | 1 + .../cell_geometry_model/model.external.c | 1 + .../cell_geometry_model/model.external.h | 1 + .../cell_geometry_model/model.external.py | 1 + .../generator/cell_geometry_model/model.h | 1 + .../generator/cell_geometry_model/model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../generator/cellml_slc_example/model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../cellml_unit_scaling_constant/model.c | 1 + .../cellml_unit_scaling_constant/model.h | 1 + .../cellml_unit_scaling_constant/model.py | 1 + .../cellml_unit_scaling_rate/model.c | 1 + .../cellml_unit_scaling_rate/model.h | 1 + .../cellml_unit_scaling_rate/model.py | 1 + .../cellml_unit_scaling_state/model.c | 1 + .../cellml_unit_scaling_state/model.h | 1 + .../cellml_unit_scaling_state/model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../cellml_unit_scaling_voi_direct/model.c | 1 + .../cellml_unit_scaling_voi_direct/model.h | 1 + .../cellml_unit_scaling_voi_direct/model.py | 1 + .../cellml_unit_scaling_voi_indirect/model.c | 1 + .../cellml_unit_scaling_voi_indirect/model.h | 1 + .../cellml_unit_scaling_voi_indirect/model.py | 1 + .../generator/dae_cellml_1_1_model/model.c | 1 + .../generator/dae_cellml_1_1_model/model.h | 1 + .../generator/dae_cellml_1_1_model/model.py | 1 + .../generator/dependent_eqns/model.c | 1 + .../generator/dependent_eqns/model.h | 1 + .../generator/dependent_eqns/model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../model.algebraic.c | 1 + .../model.algebraic.h | 1 + .../model.algebraic.py | 1 + .../model.c | 1 + .../model.computed.constant.c | 1 + .../model.computed.constant.h | 1 + .../model.computed.constant.py | 1 + .../model.constant.c | 1 + .../model.constant.h | 1 + .../model.constant.py | 1 + .../model.dae.c | 1 + .../model.dae.h | 1 + .../model.dae.py | 1 + .../model.dependent.algebraic.c | 1 + .../model.dependent.algebraic.h | 1 + .../model.dependent.algebraic.py | 1 + .../model.dependent.computed.constant.c | 1 + .../model.dependent.computed.constant.h | 1 + .../model.dependent.computed.constant.py | 1 + .../model.dependent.constant.c | 1 + .../model.dependent.constant.h | 1 + .../model.dependent.constant.py | 1 + .../model.dependent.state.c | 1 + .../model.dependent.state.h | 1 + .../model.dependent.state.py | 1 + .../model.external.c | 1 + .../model.external.h | 1 + .../model.external.py | 1 + .../model.h | 1 + .../model.py | 1 + .../model.state.c | 1 + .../model.state.h | 1 + .../model.state.py | 1 + .../generator/noble_model_1962/model.c | 1 + .../generator/noble_model_1962/model.h | 1 + .../generator/noble_model_1962/model.py | 1 + .../generator/ode_computed_var_on_rhs/model.c | 1 + .../generator/ode_computed_var_on_rhs/model.h | 1 + .../ode_computed_var_on_rhs/model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../generator/ode_const_var_on_rhs/model.c | 1 + .../generator/ode_const_var_on_rhs/model.h | 1 + .../generator/ode_const_var_on_rhs/model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../generator/ode_constant_on_rhs/model.c | 1 + .../generator/ode_constant_on_rhs/model.h | 1 + .../generator/ode_constant_on_rhs/model.py | 1 + .../ode_constant_on_rhs_one_component/model.c | 1 + .../ode_constant_on_rhs_one_component/model.h | 1 + .../model.py | 1 + .../ode_multiple_dependent_odes/model.c | 1 + .../ode_multiple_dependent_odes/model.h | 1 + .../ode_multiple_dependent_odes/model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../ode_multiple_odes_with_same_name/model.c | 1 + .../ode_multiple_odes_with_same_name/model.h | 1 + .../ode_multiple_odes_with_same_name/model.py | 1 + .../generator/ode_unknown_var_on_rhs/model.c | 1 + .../generator/ode_unknown_var_on_rhs/model.h | 1 + .../generator/ode_unknown_var_on_rhs/model.py | 1 + .../robertson_model_1966/model.dae.c | 1 + .../robertson_model_1966/model.dae.h | 1 + .../robertson_model_1966/model.dae.py | 1 + .../robertson_model_1966/model.ode.c | 1 + .../robertson_model_1966/model.ode.h | 1 + .../robertson_model_1966/model.ode.py | 1 + .../generator/sine_model_imports/model.c | 1 + .../generator/sine_model_imports/model.h | 1 + .../generator/sine_model_imports/model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + .../model.c | 1 + .../model.h | 1 + .../model.py | 1 + 202 files changed, 500 insertions(+), 5 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index d9a48da5d..3f52be0ef 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -3281,7 +3281,8 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) internalEquation->mNlaSystemIndex, equationNlaSiblings, {}, - algebraic); + algebraic, + {}); mModel->mPimpl->mEquations.push_back(equation); } diff --git a/src/analyserequation.cpp b/src/analyserequation.cpp index 7869e910d..b124f0e6c 100644 --- a/src/analyserequation.cpp +++ b/src/analyserequation.cpp @@ -34,7 +34,8 @@ void AnalyserEquation::AnalyserEquationImpl::populate(AnalyserEquation::Type typ size_t nlaSystemIndex, const std::vector &nlaSiblings, const std::vector &computedConstants, - const std::vector &algebraic) + const std::vector &algebraic, + const std::vector &externals) { mType = type; mAst = ast; @@ -44,6 +45,7 @@ void AnalyserEquation::AnalyserEquationImpl::populate(AnalyserEquation::Type typ std::copy(nlaSiblings.begin(), nlaSiblings.end(), back_inserter(mNlaSiblings)); std::copy(computedConstants.begin(), computedConstants.end(), back_inserter(mComputedConstants)); std::copy(algebraic.begin(), algebraic.end(), back_inserter(mAlgebraic)); + std::copy(externals.begin(), externals.end(), back_inserter(mExternals)); } bool AnalyserEquation::AnalyserEquationImpl::isEmptyDependency(const AnalyserEquationWeakPtr &dependency) @@ -60,6 +62,12 @@ bool AnalyserEquation::AnalyserEquationImpl::isEmptyDependency(const AnalyserEqu return false; } + auto externals = dependency.lock()->externals(); + + if (std::any_of(externals.begin(), externals.end(), [](const auto &v) { return v != nullptr; })) { + return false; + } + return true; } @@ -199,4 +207,23 @@ AnalyserVariablePtr AnalyserEquation::algebraic(size_t index) const return mPimpl->mAlgebraic[index]; } +size_t AnalyserEquation::externalCount() const +{ + return mPimpl->mExternals.size(); +} + +std::vector AnalyserEquation::externals() const +{ + return mPimpl->mExternals; +} + +AnalyserVariablePtr AnalyserEquation::external(size_t index) const +{ + if (index >= mPimpl->mExternals.size()) { + return {}; + } + + return mPimpl->mExternals[index]; +} + } // namespace libcellml diff --git a/src/analyserequation_p.h b/src/analyserequation_p.h index ae3e576af..75c2aed94 100644 --- a/src/analyserequation_p.h +++ b/src/analyserequation_p.h @@ -37,6 +37,7 @@ struct AnalyserEquation::AnalyserEquationImpl bool mIsStateRateBased = false; std::vector mComputedConstants; std::vector mAlgebraic; + std::vector mExternals; static AnalyserEquationPtr create(); @@ -46,7 +47,8 @@ struct AnalyserEquation::AnalyserEquationImpl size_t nlaSystemIndex, const std::vector &nlaSiblings, const std::vector &computedConstants, - const std::vector &algebraic); + const std::vector &algebraic, + const std::vector &externals); static bool isEmptyDependency(const AnalyserEquationWeakPtr &dependency); diff --git a/src/analysermodel.cpp b/src/analysermodel.cpp index 459b4795b..9b783f164 100644 --- a/src/analysermodel.cpp +++ b/src/analysermodel.cpp @@ -202,6 +202,33 @@ AnalyserVariablePtr AnalyserModel::algebraic(size_t index) const return mPimpl->mAlgebraic[index]; } +size_t AnalyserModel::externalCount() const +{ + if (!isValid()) { + return 0; + } + + return mPimpl->mExternals.size(); +} + +std::vector AnalyserModel::externals() const +{ + if (!isValid()) { + return {}; + } + + return mPimpl->mExternals; +} + +AnalyserVariablePtr AnalyserModel::external(size_t index) const +{ + if (!isValid() || (index >= mPimpl->mExternals.size())) { + return {}; + } + + return mPimpl->mExternals[index]; +} + size_t AnalyserModel::equationCount() const { if (!isValid()) { diff --git a/src/analysermodel_p.h b/src/analysermodel_p.h index ae7d9709c..7480584fb 100644 --- a/src/analysermodel_p.h +++ b/src/analysermodel_p.h @@ -38,6 +38,7 @@ struct AnalyserModel::AnalyserModelImpl std::vector mConstants; std::vector mComputedConstants; std::vector mAlgebraic; + std::vector mExternals; std::vector mEquations; bool mNeedEqFunction = false; diff --git a/src/api/libcellml/analyserequation.h b/src/api/libcellml/analyserequation.h index b2ca20ca0..22d7d5067 100644 --- a/src/api/libcellml/analyserequation.h +++ b/src/api/libcellml/analyserequation.h @@ -223,6 +223,35 @@ class LIBCELLML_EXPORT AnalyserEquation */ AnalyserVariablePtr algebraic(size_t index) const; + /** + * @brief Get the number of external variables computed by this @ref AnalyserEquation. + * + * Return the number of external variables computed by this @ref AnalyserEquation. + * + * @return The number of external variables. + */ + size_t externalCount() const; + + /** + * @brief Get the external variables computed by this @ref AnalyserEquation. + * + * Return the external variables computed by this @ref AnalyserEquation. + * + * @return The external variables as a @c std::vector. + */ + std::vector externals() const; + + /** + * @brief Get the external variable, at @p index, computed by this @ref AnalyserEquation. + * + * Return the external variable, at @p index, computed by this @ref AnalyserEquation. + * + * @param index The index of the external variable to return. + * + * @return The external variable, at @p index, on success, @c nullptr on failure. + */ + AnalyserVariablePtr external(size_t index) const; + private: AnalyserEquation(); /**< Constructor, @private. */ diff --git a/src/api/libcellml/analysermodel.h b/src/api/libcellml/analysermodel.h index d8e075bd7..f5d745d15 100644 --- a/src/api/libcellml/analysermodel.h +++ b/src/api/libcellml/analysermodel.h @@ -231,6 +231,36 @@ class LIBCELLML_EXPORT AnalyserModel */ AnalyserVariablePtr algebraic(size_t index) const; + /** + * @brief Get the number of external variables. + * + * Return the number of external variables in the @ref AnalyserModel. + * + * @return The number of external variables. + */ + size_t externalCount() const; + + /** + * @brief Get the external variables. + * + * Return the external variables in the @ref AnalyserModel. + * + * @return The external variables as a @c std::vector. + */ + std::vector externals() const; + + /** + * @brief Get the external variable at @p index. + * + * Return the external variable at the index @p index for the @ref AnalyserModel. + * + * @param index The index of the external variable to return. + * + * @return The external variable at the given @p index on success, @c nullptr on + * failure. + */ + AnalyserVariablePtr external(size_t index) const; + /** * @brief Get the number of equations. * diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index cbbb42f1a..4cefa11f2 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -2605,6 +2605,54 @@ class LIBCELLML_EXPORT GeneratorProfile */ void setImplementationAlgebraicCountString(const std::string &implementationAlgebraicCountString); + /** + * @brief Get the @c std::string for the interface of the external count + * constant. + * + * Return the @c std::string for the interface of the external count + * constant. + * + * @return The @c std::string for the interface of the external count + * constant. + */ + std::string interfaceExternalCountString() const; + + /** + * @brief Set the @c std::string for the interface of the external count + * constant. + * + * Set the @c std::string for the interface of the external count constant. + * + * @param interfaceExternalCountString The @c std::string to use for the + * interface of the external count constant. + */ + void setInterfaceExternalCountString(const std::string &interfaceExternalCountString); + + /** + * @brief Get the @c std::string for the implementation of the external + * count constant. + * + * Return the @c std::string for the implementation of the external count + * constant. + * + * @return The @c std::string for the implementation of the external count + * constant. + */ + std::string implementationExternalCountString() const; + + /** + * @brief Set the @c std::string for the implementation of the external + * count constant. + * + * Set the @c std::string for the implementation of the external count + * constant. To be useful, the string should contain the [EXTERNAL_COUNT] + * tag, which will be replaced with the number of states in the model. + * + * @param implementationExternalCountString The @c std::string to use for + * the implementation of the external count constant. + */ + void setImplementationExternalCountString(const std::string &implementationExternalCountString); + /** * @brief Get the @c std::string for the data structure for the variable * type object. diff --git a/src/bindings/interface/analyserequation.i b/src/bindings/interface/analyserequation.i index 8cdce8a0d..8749557bb 100644 --- a/src/bindings/interface/analyserequation.i +++ b/src/bindings/interface/analyserequation.i @@ -61,6 +61,15 @@ %feature("docstring") libcellml::AnalyserEquation::algebraic "Returns the algebraic variable, at the given index, computed by this :class:`AnalyserEquation` object."; +%feature("docstring") libcellml::AnalyserEquation::externalCount +"Returns the number of external variables computed by this :class:`AnalyserEquation` object."; + +%feature("docstring") libcellml::AnalyserEquation::externals +"Returns the external variables computed by this :class:`AnalyserEquation` object."; + +%feature("docstring") libcellml::AnalyserEquation::external +"Returns the external variable, at the given index, computed by this :class:`AnalyserEquation` object."; + %{ #include "libcellml/analyserequation.h" %} diff --git a/src/bindings/interface/analysermodel.i b/src/bindings/interface/analysermodel.i index 8933692dd..692a9d789 100644 --- a/src/bindings/interface/analysermodel.i +++ b/src/bindings/interface/analysermodel.i @@ -61,6 +61,15 @@ %feature("docstring") libcellml::AnalyserModel::algebraic "Returns the algebraic variable, specified by index, contained by this :class:`AnalyserModel` object."; +%feature("docstring") libcellml::AnalyserModel::externalCount +"Returns the number of external variables contained by this :class:`AnalyserModel` object."; + +%feature("docstring") libcellml::AnalyserModel::externals +"Returns the external variables contained by this :class:`AnalyserModel` object."; + +%feature("docstring") libcellml::AnalyserModel::external +"Returns the external variable, specified by index, contained by this :class:`AnalyserModel` object."; + %feature("docstring") libcellml::AnalyserModel::equationCount "Returns the number of equations contained by this :class:`AnalyserModel` object."; diff --git a/src/bindings/interface/generatorprofile.i b/src/bindings/interface/generatorprofile.i index 8c694e9f5..51e227c13 100644 --- a/src/bindings/interface/generatorprofile.i +++ b/src/bindings/interface/generatorprofile.i @@ -716,6 +716,19 @@ the tag, which will be replaced with the number of sta "Sets the string for the implementation of the algebraic count constant. To be useful, the string should contain the tag, which will be replaced with the number of states in the model."; +%feature("docstring") libcellml::GeneratorProfile::interfaceExternalCountString +"Returns the string for the interface of the external count constant."; + +%feature("docstring") libcellml::GeneratorProfile::setInterfaceExternalCountString +"Sets the string for the interface of the external count constant."; + +%feature("docstring") libcellml::GeneratorProfile::implementationExternalCountString +"Returns the string for the implementation of the external count constant."; + +%feature("docstring") libcellml::GeneratorProfile::setImplementationExternalCountString +"Sets the string for the implementation of the external count constant. To be useful, the string should contain +the tag, which will be replaced with the number of states in the model."; + %feature("docstring") libcellml::GeneratorProfile::variableTypeObjectString "Returns the string for the data structure for the variable type object."; diff --git a/src/bindings/javascript/analyserequation.cpp b/src/bindings/javascript/analyserequation.cpp index c7a9daf69..3b1bf0a46 100644 --- a/src/bindings/javascript/analyserequation.cpp +++ b/src/bindings/javascript/analyserequation.cpp @@ -51,6 +51,9 @@ EMSCRIPTEN_BINDINGS(libcellml_analyserequation) .function("algebraicCount", &libcellml::AnalyserEquation::algebraicCount) .function("algebraicVariables", select_overload() const>(&libcellml::AnalyserEquation::algebraic)) .function("algebraicVariable", select_overload(&libcellml::AnalyserEquation::algebraic)) + .function("externalCount", &libcellml::AnalyserEquation::externalCount) + .function("externals", select_overload() const>(&libcellml::AnalyserEquation::externals)) + .function("external", select_overload(&libcellml::AnalyserEquation::external)) ; EM_ASM( diff --git a/src/bindings/javascript/analysermodel.cpp b/src/bindings/javascript/analysermodel.cpp index 3103e413a..5182aa89b 100644 --- a/src/bindings/javascript/analysermodel.cpp +++ b/src/bindings/javascript/analysermodel.cpp @@ -54,6 +54,9 @@ EMSCRIPTEN_BINDINGS(libcellml_analysermodel) .function("algebraicCount", &libcellml::AnalyserModel::algebraicCount) .function("algebraicVariables", select_overload() const>(&libcellml::AnalyserModel::algebraic)) .function("algebraicVariable", select_overload(&libcellml::AnalyserModel::algebraic)) + .function("externalCount", &libcellml::AnalyserModel::externalCount) + .function("externals", select_overload() const>(&libcellml::AnalyserModel::externals)) + .function("external", select_overload(&libcellml::AnalyserModel::external)) .function("equationCount", &libcellml::AnalyserModel::equationCount) .function("equations", &libcellml::AnalyserModel::equations) .function("equation", &libcellml::AnalyserModel::equation) diff --git a/src/bindings/javascript/generatorprofile.cpp b/src/bindings/javascript/generatorprofile.cpp index e9fc6b420..8bb3e36c1 100644 --- a/src/bindings/javascript/generatorprofile.cpp +++ b/src/bindings/javascript/generatorprofile.cpp @@ -263,6 +263,10 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setInterfaceAlgebraicCountString", &libcellml::GeneratorProfile::setInterfaceAlgebraicCountString) .function("implementationAlgebraicCountString", &libcellml::GeneratorProfile::implementationAlgebraicCountString) .function("setImplementationAlgebraicCountString", &libcellml::GeneratorProfile::setImplementationAlgebraicCountString) + .function("interfaceExternalCountString", &libcellml::GeneratorProfile::interfaceExternalCountString) + .function("setInterfaceExternalCountString", &libcellml::GeneratorProfile::setInterfaceExternalCountString) + .function("implementationExternalCountString", &libcellml::GeneratorProfile::implementationExternalCountString) + .function("setImplementationExternalCountString", &libcellml::GeneratorProfile::setImplementationExternalCountString) .function("variableTypeObjectString", &libcellml::GeneratorProfile::variableTypeObjectString) .function("setVariableTypeObjectString", &libcellml::GeneratorProfile::setVariableTypeObjectString) .function("variableOfIntegrationVariableTypeString", &libcellml::GeneratorProfile::variableOfIntegrationVariableTypeString) diff --git a/src/generator.cpp b/src/generator.cpp index f6130eb74..d715e45b1 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -357,6 +357,14 @@ void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) "[ALGEBRAIC_COUNT]", std::to_string(mModel->algebraicCount())); } + if ((interface && !mProfile->interfaceExternalCountString().empty()) + || (!interface && !mProfile->implementationExternalCountString().empty())) { + code += interface ? + mProfile->interfaceExternalCountString() : + replace(mProfile->implementationExternalCountString(), + "[EXTERNAL_COUNT]", std::to_string(mModel->externalCount())); + } + if (!code.empty()) { mCode += "\n"; } diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 67dd5160d..ca8c24d90 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -193,6 +193,9 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mInterfaceAlgebraicCountString; std::string mImplementationAlgebraicCountString; + std::string mInterfaceExternalCountString; + std::string mImplementationExternalCountString; + std::string mVariableTypeObjectFamWoevString; std::string mVariableTypeObjectFamWevString; std::string mVariableTypeObjectFdmWoevString; @@ -522,6 +525,9 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceAlgebraicCountString = "extern const size_t ALGEBRAIC_COUNT;\n"; mImplementationAlgebraicCountString = "const size_t ALGEBRAIC_COUNT = [ALGEBRAIC_COUNT];\n"; + mInterfaceExternalCountString = "extern const size_t EXTERNAL_COUNT;\n"; + mImplementationExternalCountString = "const size_t EXTERNAL_COUNT = [EXTERNAL_COUNT];\n"; + mVariableTypeObjectFamWoevString = "typedef enum {\n" " CONSTANT,\n" " COMPUTED_CONSTANT,\n" @@ -959,6 +965,9 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceAlgebraicCountString = ""; mImplementationAlgebraicCountString = "ALGEBRAIC_COUNT = [ALGEBRAIC_COUNT]\n"; + mInterfaceExternalCountString = ""; + mImplementationExternalCountString = "EXTERNAL_COUNT = [EXTERNAL_COUNT]\n"; + mVariableTypeObjectFamWoevString = "\n" "class VariableType(Enum):\n" " CONSTANT = 0\n" @@ -2334,6 +2343,26 @@ void GeneratorProfile::setImplementationAlgebraicCountString(const std::string & mPimpl->mImplementationAlgebraicCountString = implementationAlgebraicCountString; } +std::string GeneratorProfile::interfaceExternalCountString() const +{ + return mPimpl->mInterfaceExternalCountString; +} + +void GeneratorProfile::setInterfaceExternalCountString(const std::string &interfaceExternalCountString) +{ + mPimpl->mInterfaceExternalCountString = interfaceExternalCountString; +} + +std::string GeneratorProfile::implementationExternalCountString() const +{ + return mPimpl->mImplementationExternalCountString; +} + +void GeneratorProfile::setImplementationExternalCountString(const std::string &implementationExternalCountString) +{ + mPimpl->mImplementationExternalCountString = implementationExternalCountString; +} + std::string GeneratorProfile::variableTypeObjectString(bool forDifferentialModel, bool withExternalVariables) const { diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 69f2ae4d9..17c92162a 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "f36d3c679b030a09095376711d4dc9a638a5c7b3"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "bb03c147d17a9741667957068ef629058846d2e4"; +static const char C_GENERATOR_PROFILE_SHA1[] = "d81a3e718069fa9628dccbda291fb3cf017a4cee"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "b23d6ef4b54a76f94812b78da59c2bae319bdf8d"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index 6293fd120..3410a8102 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -451,6 +451,9 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->interfaceAlgebraicCountString() + generatorProfile->implementationAlgebraicCountString(); + profileContents += generatorProfile->interfaceExternalCountString() + + generatorProfile->implementationExternalCountString(); + profileContents += generatorProfile->variableTypeObjectString(false, false); profileContents += generatorProfile->variableTypeObjectString(false, true); profileContents += generatorProfile->variableTypeObjectString(true, false); diff --git a/tests/bindings/javascript/analyserequation.test.js b/tests/bindings/javascript/analyserequation.test.js index 7619bdebd..b16f7def0 100644 --- a/tests/bindings/javascript/analyserequation.test.js +++ b/tests/bindings/javascript/analyserequation.test.js @@ -88,6 +88,15 @@ describe("Analyser Equation tests", () => { test('Checking Analyser Equation algebraicVariable.', () => { expect(eqn.algebraicVariable(0).variable().name()).toBe("x") }); + test('Checking Analyser Equation externalCount.', () => { + expect(eqn.externalCount()).toBe(0) + }); + test('Checking Analyser Equation externals.', () => { + expect(eqn.externals().size()).toBe(0) + }); + test('Checking Analyser Equation external.', () => { + expect(eqn.external(0)).toBeNull() + }); test('Checking Analyser Equation AST.', () => { expect(eqn.ast().value()).toBe("") }); diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index 92fe3b586..aa00a0e37 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -720,6 +720,18 @@ describe("GeneratorProfile tests", () => { x.setImplementationAlgebraicCountString("something") expect(x.implementationAlgebraicCountString()).toBe("something") }); + test("Checking GeneratorProfile.interfaceExternalCountString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setInterfaceExternalCountString("something") + expect(x.interfaceExternalCountString()).toBe("something") + }); + test("Checking GeneratorProfile.implementationExternalCountString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setImplementationExternalCountString("something") + expect(x.implementationExternalCountString()).toBe("something") + }); test("Checking GeneratorProfile.variableTypeObjectString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/python/test_analyser.py b/tests/bindings/python/test_analyser.py index ca3d36b0e..856ea709d 100644 --- a/tests/bindings/python/test_analyser.py +++ b/tests/bindings/python/test_analyser.py @@ -192,6 +192,9 @@ def test_coverage(self): self.assertEqual(1, ae.algebraicCount()) self.assertIsNotNone(ae.algebraic()) self.assertIsNotNone(ae.algebraic(0)) + self.assertEqual(0, ae.externalCount()) + self.assertIsNotNone(ae.externals()) + self.assertIsNone(ae.external(0)) # Check Analyser Equation type with invalid values. diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index aaa7e3271..7b3cbddb1 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -934,6 +934,15 @@ def test_implementation_algebraic_count_string(self): g.setImplementationAlgebraicCountString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationAlgebraicCountString()) + def test_implementation_external_count_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('const size_t EXTERNAL_COUNT = [EXTERNAL_COUNT];\n', g.implementationExternalCountString()) + g.setImplementationExternalCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationExternalCountString()) + def test_implementation_variable_info_string(self): from libcellml import GeneratorProfile @@ -1160,6 +1169,15 @@ def test_interface_algebraic_count_string(self): g.setInterfaceAlgebraicCountString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceAlgebraicCountString()) + def test_interface_external_count_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('extern const size_t EXTERNAL_COUNT;\n', g.interfaceExternalCountString()) + g.setInterfaceExternalCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceExternalCountString()) + def test_interface_variable_info_string(self): from libcellml import GeneratorProfile diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index ab5aac84b..83ce6b317 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -464,6 +464,10 @@ TEST(Coverage, analyser) EXPECT_EQ(size_t(0), analyserModel->algebraic().size()); EXPECT_EQ(nullptr, analyserModel->algebraic(0)); + EXPECT_EQ(size_t(0), analyserModel->externalCount()); + EXPECT_EQ(size_t(0), analyserModel->externals().size()); + EXPECT_EQ(nullptr, analyserModel->external(0)); + EXPECT_EQ(size_t(0), analyserModel->equationCount()); EXPECT_EQ(size_t(0), analyserModel->equations().size()); EXPECT_EQ(nullptr, analyserModel->equation(0)); @@ -610,6 +614,8 @@ TEST(Coverage, generator) EXPECT_EQ(nullptr, analyserModel->computedConstant(analyserModel->computedConstantCount())); EXPECT_NE(nullptr, analyserModel->algebraic(0)); EXPECT_EQ(nullptr, analyserModel->algebraic(analyserModel->algebraicCount())); + EXPECT_EQ(nullptr, analyserModel->external(0)); + EXPECT_EQ(nullptr, analyserModel->external(analyserModel->algebraicCount())); EXPECT_NE(nullptr, analyserModel->equation(199)); EXPECT_NE(size_t(0), analyserModel->equation(199)->dependencyCount()); EXPECT_NE(size_t(0), analyserModel->equation(199)->dependencies().size()); @@ -627,6 +633,10 @@ TEST(Coverage, generator) EXPECT_NE(size_t(0), analyserModel->equation(199)->algebraic().size()); EXPECT_NE(nullptr, analyserModel->equation(199)->algebraic(0)); EXPECT_EQ(nullptr, analyserModel->equation(199)->algebraic(analyserModel->equation(199)->algebraicCount())); + EXPECT_EQ(size_t(0), analyserModel->equation(199)->externalCount()); + EXPECT_EQ(size_t(0), analyserModel->equation(199)->externals().size()); + EXPECT_EQ(nullptr, analyserModel->equation(199)->external(0)); + EXPECT_EQ(nullptr, analyserModel->equation(199)->external(analyserModel->equation(199)->externalCount())); EXPECT_EQ(nullptr, analyserModel->equation(analyserModel->equationCount())); for (const auto &equation : analyserModel->equations()) { @@ -659,6 +669,12 @@ TEST(Coverage, generator) } } + for (size_t i = 0; i < analyserModel->externalCount(); ++i) { + if ((i == 1) || (i == 2) || (i == 6) || (i == 18) || (i == 179) || (i == 180) || (i == 182) || (i == 205) || (i == 206)) { + EXPECT_TRUE(analyserModel->external(i)->initialisingVariable() != nullptr); + } + } + EXPECT_EQ(nullptr, generator->model()); EXPECT_EQ(EMPTY_STRING, generator->interfaceCode()); EXPECT_EQ(EMPTY_STRING, generator->implementationCode()); @@ -716,6 +732,7 @@ TEST(Coverage, generator) profile->setImplementationConstantCountString(""); profile->setImplementationComputedConstantCountString(""); profile->setImplementationAlgebraicCountString(""); + profile->setImplementationExternalCountString(""); profile->setVariableTypeObjectString(false, false, ""); profile->setVariableTypeObjectString(false, true, ""); @@ -799,6 +816,9 @@ TEST(Coverage, generator) profile->setInterfaceAlgebraicCountString(""); profile->setImplementationAlgebraicCountString(""); + profile->setInterfaceExternalCountString(""); + profile->setImplementationExternalCountString(""); + profile->setVariableTypeObjectString(false, false, ""); profile->setVariableTypeObjectString(false, true, ""); profile->setVariableTypeObjectString(true, false, ""); diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 539e28a06..a055f922b 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -288,6 +288,9 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("extern const size_t ALGEBRAIC_COUNT;\n", generatorProfile->interfaceAlgebraicCountString()); EXPECT_EQ("const size_t ALGEBRAIC_COUNT = [ALGEBRAIC_COUNT];\n", generatorProfile->implementationAlgebraicCountString()); + EXPECT_EQ("extern const size_t EXTERNAL_COUNT;\n", generatorProfile->interfaceExternalCountString()); + EXPECT_EQ("const size_t EXTERNAL_COUNT = [EXTERNAL_COUNT];\n", generatorProfile->implementationExternalCountString()); + EXPECT_EQ("typedef enum {\n" " CONSTANT,\n" " COMPUTED_CONSTANT,\n" @@ -882,6 +885,9 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setInterfaceAlgebraicCountString(value); generatorProfile->setImplementationAlgebraicCountString(value); + generatorProfile->setInterfaceExternalCountString(value); + generatorProfile->setImplementationExternalCountString(value); + generatorProfile->setVariableTypeObjectString(false, false, value); generatorProfile->setVariableTypeObjectString(false, true, value); generatorProfile->setVariableTypeObjectString(true, false, value); @@ -1019,6 +1025,9 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->interfaceAlgebraicCountString()); EXPECT_EQ(value, generatorProfile->implementationAlgebraicCountString()); + EXPECT_EQ(value, generatorProfile->interfaceExternalCountString()); + EXPECT_EQ(value, generatorProfile->implementationExternalCountString()); + EXPECT_EQ(value, generatorProfile->variableTypeObjectString(false, false)); EXPECT_EQ(value, generatorProfile->variableTypeObjectString(false, true)); EXPECT_EQ(value, generatorProfile->variableTypeObjectString(true, false)); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 0918ab6d4..c6142792c 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 209; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index e05872689..c4835137a 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 986e59821..808684ff9 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 209; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index ef3a093e6..08fc9fc5d 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 4f4499cf7..67d01e5cf 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 209 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index b945c4eb0..ccf8c6706 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 209 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index 8eee3cf3a..7ad5b190a 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index e3f909a3f..665df9668 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_eqn", ALGEBRAIC}, diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index 8b56d9b9f..976333877 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 830a7dbcc..1d135a8d6 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index 8b9a1fb66..ffa08d417 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index abbf71111..a89a1f872 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index 332ca7406..a90730192 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index 8b9a1fb66..ffa08d417 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index 491cd5db6..cac3a4142 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index 89a7cc42a..b2142ca77 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_component", COMPUTED_CONSTANT} diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index d26413c67..e5928a2fe 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index bbee07879..e5238d296 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 3dad3588b..9cb7a3000 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index 1eeee2f1e..02e634a29 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 636d498eb..ed4157ad3 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 7c848f430..75a65fe9c 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index ca79cc5f2..89890cfa6 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 1b1a4ab6e..2e6d45e10 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 42c4bd5eb..c6a0f3adf 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index d2a3025e3..60658293a 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 1515ba774..fe2cececb 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 02fe6c001..2a8dbbed5 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_model", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index cfae2b1d2..e98ffacdf 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 25de4def2..a91cadb06 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 76b2c4760..75c1d28ae 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 4; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"b", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index 060991c4c..ce37e089b 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 4; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"b", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index 8b56d9b9f..976333877 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 136bed0a6..3998dee56 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 4 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index 8b9a1fb66..ffa08d417 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index c84ffdf6a..e823ec04a 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 4 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index eb6d409ad..3fed4a9e1 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 3; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_system", ALGEBRAIC}, diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index 69ce3f676..fee170f4b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index de50e042e..16bd44fe4 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 3 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index db8bace3d..827f341f9 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 3; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_system", EXTERNAL}, diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index f8cc4af0b..0c3b6b4a5 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index 0e99da282..bdb2fe0fe 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 3 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index c628b10ac..c1b94c182 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 6; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"d", "dimensionless", "my_algebraic_system", ALGEBRAIC}, diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index 69ce3f676..fee170f4b 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 083873c38..8a734a9a3 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 6 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index c7e93bd95..15de97b49 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 6; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT}, diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index 69ce3f676..fee170f4b 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 8b965af0b..e842a7e56 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 6 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index 16b90c388..0fab3f892 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_component", COMPUTED_CONSTANT}, diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index d26413c67..e5928a2fe 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 3edee3ead..53f8993bf 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index a5db4ad9c..e6391bb73 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 4; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"vcell", "microlitre", "cell_geometry", COMPUTED_CONSTANT}, diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index ed88fb63d..8ecb305e9 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 4; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"vcell", "microlitre", "cell_geometry", ALGEBRAIC}, diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 6974bd646..413845298 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 752da86d5..2bf7fb613 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 4 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index d291cbc39..ef37e5ea5 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index 6c941fc86..eb269347e 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 4 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 3f59baaf8..92bf0a4fb 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index 91a2bbdb9..2aab41a47 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 42799d811..8ecaaaaa4 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index f13fcec59..5ffe3d04e 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 10 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index 3bb1425bc..88193e176 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index e95d12eb1..1a5d4ce25 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 2ae891fe3..ff1defc39 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index dea2a68ea..616edc403 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 3; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"k", "mM", "constants", CONSTANT}, diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index 435deb74f..ed21d6473 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index ec8df9c83..6cd14b1a9 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 3 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 603a1eab3..87f36e81d 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index e95d12eb1..1a5d4ce25 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index f74588e12..572138bfc 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 34c1bca1f..0e2889515 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index e95d12eb1..1a5d4ce25 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index ec43146e3..ea1dd2f48 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index c0db3b3a3..9689d4fc9 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index bd4dd923e..fe3771382 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index 86e48a995..214d36e3f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index ba05a38f2..cf6cc5619 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index fc9911e7e..480606249 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index ce584f1b0..084fde5b2 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index f0e1d42ba..022b4ee5a 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index 3f1fb63fd..cc72c5b3a 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index e14df017f..8f5a9954f 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index cd6840c59..37a9e4aa4 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 123e68564..2c159313c 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index ac4a5b309..fbb32f6af 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 89c29978d..91a85192a 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 10; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "main", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 2bcb43579..12391c848 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index c1147dd4f..c08f81990 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 10 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 7bbb98144..8afaa994e 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 676c75fec..bfb9e7234 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index 5ed89e910..9f9268732 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index bfbc945a4..839f56874 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 33; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 217; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index e94e9dec0..72e65f564 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 3141afa7a..bf46049b2 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 217 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 05de7d9e6..19a61164c 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 15; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 185; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 2715ae2d9..7ce78ee1d 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index b07aec10e..c62e1982c 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 185 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index fd4eb1dfc..cd52f7451 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 18; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index 3435c028a..8ae5a3e5d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 9b752f340..a741566be 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 18 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 33d70c70c..f687edd86 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 18; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 4dd1a09a6..c56e1e8f4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 18; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index 3435c028a..8ae5a3e5d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 4d8a09531..796983378 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 18 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index b38a8dde5..1cc4901fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 18; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index 3435c028a..8ae5a3e5d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 9a8335d0d..b78d3d588 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 18 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 228073aca..cfcaf93f2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 18; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index 2379ada7d..be76c88f6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index e9fe6851d..fbc3704f8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 18 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 196709742..2da76b8e8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 18; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index 3435c028a..8ae5a3e5d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 006bf3b12..4a645f071 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 18 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 96ead04c7..50798a796 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 18; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index 3435c028a..8ae5a3e5d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index c3a219727..e83d4154e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 18 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index e78468a05..c608b0c7f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 18; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index 3435c028a..8ae5a3e5d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index fb7c5c7ff..81364cfcb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 18 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index daca5bba8..5627364ba 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 20; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index 3435c028a..8ae5a3e5d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 02be0961d..d887340c1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 20 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 6daaf81cf..329a24f94 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 19; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index 3435c028a..8ae5a3e5d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 0cbe773e1..019a0c857 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 19 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index 2379ada7d..be76c88f6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 68e90fdd0..b37f2884e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 18 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index fa7028471..1f5098cc5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 19; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index 3435c028a..8ae5a3e5d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index d1748c002..b68a159ff 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 19 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index d0434bbc6..b2b3956e7 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 17; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index a4c365da2..8149205d0 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 04b3307a0..8fb96500a 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 17 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 1bf89a3b8..4e9479368 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index 3f1fb63fd..cc72c5b3a 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index e60d2476d..4c7b0bfdf 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index cf371f670..9462cd1de 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index ca79cc5f2..89890cfa6 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 847ad0446..ff803cc8f 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index da29f52f6..6c6342e78 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index 3f1fb63fd..cc72c5b3a 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 351e628e4..283bdd003 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index 9f18d3d5e..0b0fb3bb3 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index ca79cc5f2..89890cfa6 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 0ed240fa5..986a9feb1 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index 71e7ea5a8..83124f7ed 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index 3f1fb63fd..cc72c5b3a 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index bc525feb5..00b49ef0f 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index a37c8889b..997ae718f 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index ca79cc5f2..89890cfa6 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index 22311d1da..72fd031fc 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 89cfc22b7..6d83c015c 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index cc74aaa0b..14013eaef 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 34b35116b..9f9df39e8 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 00d0e6e7a..21f46b37f 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index f0d48d38d..2c7d5a183 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 59377dde9..b4fff77d2 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index b3c86f5bb..461288218 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index 0b0953abe..d4cb731d4 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 93bd5d2fd..67babcba7 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index 0b29e548b..e46429232 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index 3f1fb63fd..cc72c5b3a 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 2f19ddc26..a19fdebbf 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 90bfcb513..63de63a9f 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 5; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index bca2cef3a..653f64a63 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 034f6a13c..b5f40fc30 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 5 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 51c94697b..0bc157d92 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 4; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index bca2cef3a..653f64a63 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index f702e804d..f96e5d878 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 4 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 0f52edcd5..02fb665ff 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 10; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"x", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index 93c965f33..ad2862fae 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 065f85ab7..4c559e5e1 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 10 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index db7744dbb..015da83af 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -11,6 +11,7 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 10; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"v", "fmol_per_sec", "SLC_template3_ss", ALGEBRAIC}, diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 774d63753..92576c047 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -10,6 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index f07ad2cca..e09f76a95 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -10,6 +10,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 10 +EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 79800b918..004fa4ce5 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -12,6 +12,7 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "component_1", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index 340f578dd..890a583bb 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 54a115939..0c4afd730 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -11,6 +11,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 0 class VariableType(Enum): From ef864477c757bc634d6229d77df6f22b17823c7b Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 8 Aug 2024 17:30:16 +0200 Subject: [PATCH 14/74] Updated JavaScript tests. --- tests/bindings/javascript/analyservariable.test.js | 2 +- tests/bindings/javascript/generator.test.js | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/bindings/javascript/analyservariable.test.js b/tests/bindings/javascript/analyservariable.test.js index 6aa1f4f8d..733684b5d 100644 --- a/tests/bindings/javascript/analyservariable.test.js +++ b/tests/bindings/javascript/analyservariable.test.js @@ -48,7 +48,7 @@ describe("Analyser Variable tests", () => { }); test('Checking Analyser Variable index.', () => { const av = am.algebraicVariable(7) - expect(av.index()).toBe(7) + expect(av.index()).toBe(2) }); test('Checking Analyser Variable initialising variable.', () => { const av = am.algebraicVariable(15) diff --git a/tests/bindings/javascript/generator.test.js b/tests/bindings/javascript/generator.test.js index bd854e65f..be7e04ebd 100644 --- a/tests/bindings/javascript/generator.test.js +++ b/tests/bindings/javascript/generator.test.js @@ -62,10 +62,10 @@ describe("Generator tests", () => { g.setModel(a.model()) const interface_lines = g.interfaceCode().split('\n') - expect(interface_lines.length).toBe(42) + expect(interface_lines.length).toBe(43) const implementation_lines = g.implementationCode().split('\n') - expect(implementation_lines.length).toBe(69) + expect(implementation_lines.length).toBe(70) const equation_line_1 = libcellml.Generator.equationCode(a.model().equation(0).ast()) expect(equation_line_1.length).toBe(14) From 9d7174dd735290df0162aac6e30035fd86bc5ac4 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 8 Aug 2024 18:12:56 +0200 Subject: [PATCH 15/74] Analyser: keep track of computed constants and external variables for an equation. We will also need to keep track of states and constants. --- src/analyser.cpp | 33 ++++++++++++++++++++++++++++++--- src/utilities.cpp | 6 ++++++ 2 files changed, 36 insertions(+), 3 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index 3f52be0ef..ee0663f96 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -3147,13 +3147,40 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Determine all the variables computed by the equation, as well as // whether the equation is an external one. + AnalyserVariablePtrs computedConstants; AnalyserVariablePtrs algebraic; + AnalyserVariablePtrs externals; auto externalEquation = true; for (const auto &unknownVariable : internalEquation->mUnknownVariables) { auto variable = aiv2avMappings[unknownVariable]; - algebraic.push_back(variable); + switch (variable->type()) { + case AnalyserVariable::Type::STATE: + algebraic.push_back(variable); //---GRY--- states.push_back(variable); + + break; + case AnalyserVariable::Type::CONSTANT: + algebraic.push_back(variable); //---GRY--- constants.push_back(variable); + + break; + case AnalyserVariable::Type::COMPUTED_CONSTANT: + computedConstants.push_back(variable); + + break; + case AnalyserVariable::Type::ALGEBRAIC: + algebraic.push_back(variable); + + break; + case AnalyserVariable::Type::EXTERNAL: + externals.push_back(variable); + + break; + default: // AnalyserVariable::Type::VARIABLE_OF_INTEGRATION. + // This is the variable of integration, which cannot be computed. + + break; + } if (variable->type() != AnalyserVariable::Type::EXTERNAL) { externalEquation = false; @@ -3280,9 +3307,9 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) equationDependencies, internalEquation->mNlaSystemIndex, equationNlaSiblings, - {}, + computedConstants, algebraic, - {}); + externals); mModel->mPimpl->mEquations.push_back(equation); } diff --git a/src/utilities.cpp b/src/utilities.cpp index f59b00d29..ff478630a 100644 --- a/src/utilities.cpp +++ b/src/utilities.cpp @@ -1344,6 +1344,12 @@ std::vector variables(const AnalyserEquationPtr &equation) res.insert(res.end(), algebraic.begin(), algebraic.end()); } + auto externals = equation->externals(); + + if (!externals.empty()) { + res.insert(res.end(), externals.begin(), externals.end()); + } + return res; } From 60b26bc14ab55e114ba6136534608190fbc33ba5 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 8 Aug 2024 18:42:30 +0200 Subject: [PATCH 16/74] Analyser: some minor cleaning up. --- src/analyser.cpp | 86 ++++++++++++++++++++-------------------- src/analyserequation.cpp | 20 ---------- src/analyserequation_p.h | 15 ++----- src/analysermodel_p.h | 2 + src/generator.cpp | 7 ++-- 5 files changed, 52 insertions(+), 78 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index ee0663f96..28584fb80 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -3144,47 +3144,16 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Make our internal equations available through our API. for (const auto &internalEquation : mInternalEquations) { - // Determine all the variables computed by the equation, as well as - // whether the equation is an external one. + // Determine whether the equation is an external one. - AnalyserVariablePtrs computedConstants; - AnalyserVariablePtrs algebraic; - AnalyserVariablePtrs externals; auto externalEquation = true; for (const auto &unknownVariable : internalEquation->mUnknownVariables) { - auto variable = aiv2avMappings[unknownVariable]; - - switch (variable->type()) { - case AnalyserVariable::Type::STATE: - algebraic.push_back(variable); //---GRY--- states.push_back(variable); - - break; - case AnalyserVariable::Type::CONSTANT: - algebraic.push_back(variable); //---GRY--- constants.push_back(variable); - - break; - case AnalyserVariable::Type::COMPUTED_CONSTANT: - computedConstants.push_back(variable); - - break; - case AnalyserVariable::Type::ALGEBRAIC: - algebraic.push_back(variable); - - break; - case AnalyserVariable::Type::EXTERNAL: - externals.push_back(variable); - - break; - default: // AnalyserVariable::Type::VARIABLE_OF_INTEGRATION. - // This is the variable of integration, which cannot be computed. + if (aiv2avMappings[unknownVariable]->type() != AnalyserVariable::Type::EXTERNAL) { + externalEquation = false; break; } - - if (variable->type() != AnalyserVariable::Type::EXTERNAL) { - externalEquation = false; - } } // Determine the type of the equation. @@ -3300,16 +3269,45 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) auto equation = aie2aeMappings[internalEquation]; - equation->mPimpl->populate(type, - (type == AnalyserEquation::Type::EXTERNAL) ? - nullptr : - internalEquation->mAst, - equationDependencies, - internalEquation->mNlaSystemIndex, - equationNlaSiblings, - computedConstants, - algebraic, - externals); + equation->mPimpl->mType = type; + equation->mPimpl->mAst = (type == AnalyserEquation::Type::EXTERNAL) ? + nullptr : + internalEquation->mAst; + equation->mPimpl->mNlaSystemIndex = internalEquation->mNlaSystemIndex; + + for (const auto &unknownVariable : internalEquation->mUnknownVariables) { + auto variable = aiv2avMappings[unknownVariable]; + + switch (variable->type()) { + case AnalyserVariable::Type::STATE: + equation->mPimpl->mAlgebraic.push_back(variable); //---GRY--- equation->mPimpl->mStates.push_back(variable); + + break; + case AnalyserVariable::Type::CONSTANT: + equation->mPimpl->mAlgebraic.push_back(variable); //---GRY--- equation->mPimpl->mConstants.push_back(variable); + + break; + case AnalyserVariable::Type::COMPUTED_CONSTANT: + equation->mPimpl->mComputedConstants.push_back(variable); + + break; + case AnalyserVariable::Type::ALGEBRAIC: + equation->mPimpl->mAlgebraic.push_back(variable); + + break; + case AnalyserVariable::Type::EXTERNAL: + equation->mPimpl->mExternals.push_back(variable); + + break; + default: // AnalyserVariable::Type::VARIABLE_OF_INTEGRATION. + // This is the variable of integration, which cannot be computed. + + break; + } + } + + std::copy(equationDependencies.begin(), equationDependencies.end(), back_inserter(equation->mPimpl->mDependencies)); + std::copy(equationNlaSiblings.begin(), equationNlaSiblings.end(), back_inserter(equation->mPimpl->mNlaSiblings)); mModel->mPimpl->mEquations.push_back(equation); } diff --git a/src/analyserequation.cpp b/src/analyserequation.cpp index b124f0e6c..7caf807ce 100644 --- a/src/analyserequation.cpp +++ b/src/analyserequation.cpp @@ -28,26 +28,6 @@ AnalyserEquationPtr AnalyserEquation::AnalyserEquationImpl::create() return std::shared_ptr {new AnalyserEquation {}}; } -void AnalyserEquation::AnalyserEquationImpl::populate(AnalyserEquation::Type type, - const AnalyserEquationAstPtr &ast, - const std::vector &dependencies, - size_t nlaSystemIndex, - const std::vector &nlaSiblings, - const std::vector &computedConstants, - const std::vector &algebraic, - const std::vector &externals) -{ - mType = type; - mAst = ast; - mNlaSystemIndex = nlaSystemIndex; - - std::copy(dependencies.begin(), dependencies.end(), back_inserter(mDependencies)); - std::copy(nlaSiblings.begin(), nlaSiblings.end(), back_inserter(mNlaSiblings)); - std::copy(computedConstants.begin(), computedConstants.end(), back_inserter(mComputedConstants)); - std::copy(algebraic.begin(), algebraic.end(), back_inserter(mAlgebraic)); - std::copy(externals.begin(), externals.end(), back_inserter(mExternals)); -} - bool AnalyserEquation::AnalyserEquationImpl::isEmptyDependency(const AnalyserEquationWeakPtr &dependency) { auto computedConstants = dependency.lock()->computedConstants(); diff --git a/src/analyserequation_p.h b/src/analyserequation_p.h index 75c2aed94..471fd9b97 100644 --- a/src/analyserequation_p.h +++ b/src/analyserequation_p.h @@ -31,24 +31,17 @@ struct AnalyserEquation::AnalyserEquationImpl { AnalyserEquation::Type mType = AnalyserEquation::Type::ALGEBRAIC; AnalyserEquationAstPtr mAst; - std::vector mDependencies; size_t mNlaSystemIndex; - std::vector mNlaSiblings; bool mIsStateRateBased = false; + std::vector mComputedConstants; std::vector mAlgebraic; std::vector mExternals; - static AnalyserEquationPtr create(); + std::vector mDependencies; + std::vector mNlaSiblings; - void populate(AnalyserEquation::Type type, - const AnalyserEquationAstPtr &ast, - const std::vector &dependencies, - size_t nlaSystemIndex, - const std::vector &nlaSiblings, - const std::vector &computedConstants, - const std::vector &algebraic, - const std::vector &externals); + static AnalyserEquationPtr create(); static bool isEmptyDependency(const AnalyserEquationWeakPtr &dependency); diff --git a/src/analysermodel_p.h b/src/analysermodel_p.h index 7480584fb..24cb80e58 100644 --- a/src/analysermodel_p.h +++ b/src/analysermodel_p.h @@ -34,11 +34,13 @@ struct AnalyserModel::AnalyserModelImpl bool mHasExternalVariables = false; AnalyserVariablePtr mVoi; + std::vector mStates; std::vector mConstants; std::vector mComputedConstants; std::vector mAlgebraic; std::vector mExternals; + std::vector mEquations; bool mNeedEqFunction = false; diff --git a/src/generator.cpp b/src/generator.cpp index d715e45b1..e0e316a2e 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1897,7 +1897,9 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st // Initialise our true constants. - for (const auto &equation : mModel->equations()) { + auto equations = mModel->equations(); + + for (const auto &equation : equations) { if (equation->type() == AnalyserEquation::Type::TRUE_CONSTANT) { methodBody += generateEquationCode(equation, remainingEquations); } @@ -1921,14 +1923,13 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st // Initialise our external variables. if (mModel->hasExternalVariables()) { - auto equations = mModel->equations(); std::vector remainingExternalEquations; std::copy_if(equations.begin(), equations.end(), std::back_inserter(remainingExternalEquations), [](const AnalyserEquationPtr &equation) { return equation->type() == AnalyserEquation::Type::EXTERNAL; }); - for (const auto &equation : mModel->equations()) { + for (const auto &equation : equations) { if (equation->type() == AnalyserEquation::Type::EXTERNAL) { methodBody += generateEquationCode(equation, remainingExternalEquations); } From 05aa33897ec9da53c6ab32a2a1de10f7fa746ed0 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 8 Aug 2024 21:50:19 +0200 Subject: [PATCH 17/74] AnalyserModel: keep track of the constants, computed constants, and external variables. --- src/analyser.cpp | 25 ++- src/generator.cpp | 15 +- src/utilities.cpp | 6 + .../bindings/javascript/analysermodel.test.js | 16 +- .../javascript/analyservariable.test.js | 22 +-- tests/bindings/javascript/generator.test.js | 4 +- tests/bindings/python/test_analyser.py | 18 +- tests/coverage/coverage.cpp | 30 +-- tests/resources/coverage/generator/model.c | 25 ++- tests/resources/coverage/generator/model.h | 1 - .../generator/model.modified.profile.c | 25 ++- .../generator/model.modified.profile.h | 1 - .../generator/model.modified.profile.py | 25 ++- tests/resources/coverage/generator/model.py | 25 ++- .../algebraic_eqn_computed_var_on_rhs/model.c | 5 +- .../model.external.c | 4 +- .../model.external.py | 4 +- .../algebraic_eqn_computed_var_on_rhs/model.h | 1 - .../model.py | 5 +- .../algebraic_eqn_const_var_on_rhs/model.c | 11 +- .../algebraic_eqn_const_var_on_rhs/model.h | 1 - .../algebraic_eqn_const_var_on_rhs/model.py | 11 +- .../algebraic_eqn_constant_on_rhs/model.c | 5 +- .../algebraic_eqn_constant_on_rhs/model.h | 1 - .../algebraic_eqn_constant_on_rhs/model.py | 5 +- .../algebraic_eqn_derivative_on_rhs/model.c | 5 +- .../algebraic_eqn_derivative_on_rhs/model.h | 1 - .../algebraic_eqn_derivative_on_rhs/model.py | 5 +- .../model.c | 5 +- .../model.h | 1 - .../model.py | 5 +- .../algebraic_eqn_state_var_on_rhs/model.c | 5 +- .../algebraic_eqn_state_var_on_rhs/model.h | 1 - .../algebraic_eqn_state_var_on_rhs/model.py | 5 +- .../model.c | 5 +- .../model.h | 1 - .../model.py | 5 +- .../model.c | 5 +- .../model.external.c | 6 +- .../model.external.py | 6 +- .../model.h | 1 - .../model.py | 5 +- .../model.c | 1 - .../model.h | 1 - .../model.py | 1 - .../model.three.externals.c | 4 +- .../model.three.externals.h | 6 +- .../model.three.externals.py | 4 +- .../model.not.ordered.c | 19 +- .../model.not.ordered.h | 1 - .../model.not.ordered.py | 19 +- .../model.ordered.c | 9 +- .../model.ordered.h | 1 - .../model.ordered.py | 9 +- .../algebraic_unknown_var_on_rhs/model.c | 5 +- .../algebraic_unknown_var_on_rhs/model.h | 1 - .../algebraic_unknown_var_on_rhs/model.py | 5 +- .../generator/cell_geometry_model/model.c | 9 +- .../cell_geometry_model/model.external.c | 8 +- .../cell_geometry_model/model.external.py | 8 +- .../generator/cell_geometry_model/model.h | 1 - .../generator/cell_geometry_model/model.py | 9 +- .../model.c | 1 - .../model.h | 1 - .../model.py | 1 - .../generator/cellml_slc_example/model.py | 11 +- .../model.c | 5 +- .../model.h | 1 - .../model.py | 5 +- .../cellml_unit_scaling_constant/model.c | 7 +- .../cellml_unit_scaling_constant/model.h | 1 - .../cellml_unit_scaling_constant/model.py | 7 +- .../cellml_unit_scaling_rate/model.c | 1 - .../cellml_unit_scaling_rate/model.h | 1 - .../cellml_unit_scaling_rate/model.py | 1 - .../cellml_unit_scaling_state/model.c | 1 - .../cellml_unit_scaling_state/model.h | 1 - .../cellml_unit_scaling_state/model.py | 1 - .../model.c | 1 - .../model.h | 1 - .../model.py | 1 - .../model.c | 5 +- .../model.h | 1 - .../model.py | 5 +- .../cellml_unit_scaling_voi_direct/model.c | 1 - .../cellml_unit_scaling_voi_direct/model.h | 1 - .../cellml_unit_scaling_voi_direct/model.py | 1 - .../cellml_unit_scaling_voi_indirect/model.c | 1 - .../cellml_unit_scaling_voi_indirect/model.h | 1 - .../cellml_unit_scaling_voi_indirect/model.py | 1 - .../generator/dae_cellml_1_1_model/model.c | 21 +- .../generator/dae_cellml_1_1_model/model.h | 1 - .../generator/dae_cellml_1_1_model/model.py | 21 +- .../generator/dependent_eqns/model.c | 1 - .../generator/dependent_eqns/model.h | 1 - .../generator/dependent_eqns/model.py | 1 - .../model.c | 185 +++++++++--------- .../model.h | 1 - .../model.py | 185 +++++++++--------- .../model.c | 153 +++++++-------- .../model.h | 1 - .../model.py | 153 +++++++-------- .../model.algebraic.c | 26 +-- .../model.algebraic.py | 26 +-- .../model.c | 23 ++- .../model.computed.constant.c | 26 +-- .../model.computed.constant.py | 26 +-- .../model.constant.c | 26 +-- .../model.constant.py | 26 +-- .../model.dae.c | 39 ++-- .../model.dae.h | 1 - .../model.dae.py | 39 ++-- .../model.dependent.algebraic.c | 24 +-- .../model.dependent.algebraic.py | 24 +-- .../model.dependent.computed.constant.c | 20 +- .../model.dependent.computed.constant.py | 20 +- .../model.dependent.constant.c | 26 +-- .../model.dependent.constant.py | 26 +-- .../model.dependent.state.c | 30 +-- .../model.dependent.state.py | 30 +-- .../model.external.c | 30 +-- .../model.external.py | 30 +-- .../model.h | 1 - .../model.py | 23 ++- .../model.state.c | 28 +-- .../model.state.py | 28 +-- .../generator/noble_model_1962/model.c | 13 +- .../generator/noble_model_1962/model.h | 1 - .../generator/noble_model_1962/model.py | 13 +- .../generator/ode_computed_var_on_rhs/model.c | 5 +- .../generator/ode_computed_var_on_rhs/model.h | 1 - .../ode_computed_var_on_rhs/model.py | 5 +- .../model.c | 5 +- .../model.h | 1 - .../model.py | 5 +- .../generator/ode_const_var_on_rhs/model.c | 5 +- .../generator/ode_const_var_on_rhs/model.h | 1 - .../generator/ode_const_var_on_rhs/model.py | 5 +- .../model.c | 5 +- .../model.h | 1 - .../model.py | 5 +- .../generator/ode_constant_on_rhs/model.c | 1 - .../generator/ode_constant_on_rhs/model.h | 1 - .../generator/ode_constant_on_rhs/model.py | 1 - .../ode_constant_on_rhs_one_component/model.c | 1 - .../ode_constant_on_rhs_one_component/model.h | 1 - .../model.py | 1 - .../ode_multiple_dependent_odes/model.c | 5 +- .../ode_multiple_dependent_odes/model.h | 1 - .../ode_multiple_dependent_odes/model.py | 5 +- .../model.c | 5 +- .../model.h | 1 - .../model.py | 5 +- .../ode_multiple_odes_with_same_name/model.c | 5 +- .../ode_multiple_odes_with_same_name/model.h | 1 - .../ode_multiple_odes_with_same_name/model.py | 5 +- .../generator/ode_unknown_var_on_rhs/model.c | 1 - .../generator/ode_unknown_var_on_rhs/model.h | 1 - .../generator/ode_unknown_var_on_rhs/model.py | 1 - .../robertson_model_1966/model.dae.c | 9 +- .../robertson_model_1966/model.dae.h | 1 - .../robertson_model_1966/model.dae.py | 9 +- .../robertson_model_1966/model.ode.c | 5 +- .../robertson_model_1966/model.ode.h | 1 - .../robertson_model_1966/model.ode.py | 5 +- .../generator/sine_model_imports/model.c | 11 +- .../generator/sine_model_imports/model.h | 1 - .../generator/sine_model_imports/model.py | 11 +- .../model.c | 8 +- .../model.py | 8 +- .../model.c | 5 +- .../model.h | 1 - .../model.py | 5 +- 173 files changed, 964 insertions(+), 1096 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index 28584fb80..f0caa7b86 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -3134,10 +3134,31 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) aiv2avMappings.emplace(internalVariable, variable); v2avMappings.emplace(internalVariable->mVariable, variable); - if (type == AnalyserVariable::Type::STATE) { + switch (type) { + case AnalyserVariable::Type::STATE: mModel->mPimpl->mStates.push_back(variable); - } else { + + break; + case AnalyserVariable::Type::CONSTANT: + mModel->mPimpl->mConstants.push_back(variable); + + break; + case AnalyserVariable::Type::COMPUTED_CONSTANT: + mModel->mPimpl->mComputedConstants.push_back(variable); + + break; + case AnalyserVariable::Type::ALGEBRAIC: mModel->mPimpl->mAlgebraic.push_back(variable); + + break; + case AnalyserVariable::Type::EXTERNAL: + mModel->mPimpl->mExternals.push_back(variable); + + break; + default: // AnalyserVariable::Type::VARIABLE_OF_INTEGRATION. + // This is the variable of integration, so skip it. + + break; } } diff --git a/src/generator.cpp b/src/generator.cpp index e0e316a2e..44671415e 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -95,15 +95,7 @@ AnalyserVariablePtr Generator::GeneratorImpl::analyserVariable(const VariablePtr res = doAnalyserVariable(variable, mModel->states()); if (res == nullptr) { - res = doAnalyserVariable(variable, mModel->constants()); - } - - if (res == nullptr) { - res = doAnalyserVariable(variable, mModel->computedConstants()); - } - - if (res == nullptr) { - res = doAnalyserVariable(variable, mModel->algebraic()); + res = doAnalyserVariable(variable, variables(mModel)); } } @@ -357,8 +349,9 @@ void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) "[ALGEBRAIC_COUNT]", std::to_string(mModel->algebraicCount())); } - if ((interface && !mProfile->interfaceExternalCountString().empty()) - || (!interface && !mProfile->implementationExternalCountString().empty())) { + if ((mModel->externalCount() != 0) + && ((interface && !mProfile->interfaceExternalCountString().empty()) + || (!interface && !mProfile->implementationExternalCountString().empty()))) { code += interface ? mProfile->interfaceExternalCountString() : replace(mProfile->implementationExternalCountString(), diff --git a/src/utilities.cpp b/src/utilities.cpp index ff478630a..77815b38b 100644 --- a/src/utilities.cpp +++ b/src/utilities.cpp @@ -1332,6 +1332,12 @@ std::vector variables(const AnalyserModelPtr &model) res.insert(res.end(), algebraic.begin(), algebraic.end()); } + auto externals = model->externals(); + + if (!externals.empty()) { + res.insert(res.end(), externals.begin(), externals.end()); + } + return res; } diff --git a/tests/bindings/javascript/analysermodel.test.js b/tests/bindings/javascript/analysermodel.test.js index c709d9368..7c5ea9ada 100644 --- a/tests/bindings/javascript/analysermodel.test.js +++ b/tests/bindings/javascript/analysermodel.test.js @@ -62,18 +62,18 @@ describe("Analyser Model tests", () => { expect(am.state(2).variable().name()).toBe("m") }); test('Checking Analyser Model constants related API.', () => { - expect(am.constantCount()).toBe(0) - expect(am.constants().size()).toBe(0) - expect(am.constant(2)).toBeNull() + expect(am.constantCount()).toBe(5) + expect(am.constants().size()).toBe(5) + expect(am.constant(2).variable().name()).toBe("g_L") }); test('Checking Analyser Model computed constants related API.', () => { - expect(am.computedConstantCount()).toBe(0) - expect(am.computedConstants().size()).toBe(0) - expect(am.computedConstant(2)).toBeNull() + expect(am.computedConstantCount()).toBe(3) + expect(am.computedConstants().size()).toBe(3) + expect(am.computedConstant(2).variable().name()).toBe("E_K") }); test('Checking Analyser Model algebraic variables related API.', () => { - expect(am.algebraicCount()).toBe(18) - expect(am.algebraicVariables().size()).toBe(18) + expect(am.algebraicCount()).toBe(10) + expect(am.algebraicVariables().size()).toBe(10) expect(am.algebraicVariable(2).variable().name()).toBe("i_K") }); test('Checking Analyser Model need* API.', () => { diff --git a/tests/bindings/javascript/analyservariable.test.js b/tests/bindings/javascript/analyservariable.test.js index 733684b5d..802612656 100644 --- a/tests/bindings/javascript/analyservariable.test.js +++ b/tests/bindings/javascript/analyservariable.test.js @@ -37,9 +37,9 @@ describe("Analyser Variable tests", () => { am = a.model() - expect(am.constantCount()).toBe(0) - expect(am.computedConstantCount()).toBe(0) - expect(am.algebraicCount()).toBe(18) + expect(am.constantCount()).toBe(5) + expect(am.computedConstantCount()).toBe(3) + expect(am.algebraicCount()).toBe(10) }); test('Checking Analyser Variable type.', () => { const av = am.algebraicVariable(0) @@ -48,26 +48,26 @@ describe("Analyser Variable tests", () => { }); test('Checking Analyser Variable index.', () => { const av = am.algebraicVariable(7) - expect(av.index()).toBe(2) + expect(av.index()).toBe(7) }); test('Checking Analyser Variable initialising variable.', () => { - const av = am.algebraicVariable(15) - expect(av.initialisingVariable().name()).toBe("g_K") + const av = am.constant(3) + expect(av.initialisingVariable().name()).toBe("g_Na") }); test('Checking Analyser Variable variable.', () => { - const av = am.algebraicVariable(10) - expect(av.variable().name()).toBe("alpha_m") + const av = am.algebraicVariable(3) + expect(av.variable().name()).toBe("i_Na") }); test('Checking Analyser Equation equationCount.', () => { - const av = am.algebraicVariable(14) + const av = am.computedConstant(1) expect(av.equationCount()).toBe(1) }); test('Checking Analyser Variable equations.', () => { - const av = am.algebraicVariable(14) + const av = am.computedConstant(1) expect(av.equations().size()).toBe(1) }); test('Checking Analyser Variable equation.', () => { - const av = am.algebraicVariable(14) + const av = am.computedConstant(1) expect(av.equation(0).type().value).toBe(libcellml.AnalyserEquation.Type.VARIABLE_BASED_CONSTANT.value) }); }) diff --git a/tests/bindings/javascript/generator.test.js b/tests/bindings/javascript/generator.test.js index be7e04ebd..bd854e65f 100644 --- a/tests/bindings/javascript/generator.test.js +++ b/tests/bindings/javascript/generator.test.js @@ -62,10 +62,10 @@ describe("Generator tests", () => { g.setModel(a.model()) const interface_lines = g.interfaceCode().split('\n') - expect(interface_lines.length).toBe(43) + expect(interface_lines.length).toBe(42) const implementation_lines = g.implementationCode().split('\n') - expect(implementation_lines.length).toBe(70) + expect(implementation_lines.length).toBe(69) const equation_line_1 = libcellml.Generator.equationCode(a.model().equation(0).ast()) expect(equation_line_1.length).toBe(14) diff --git a/tests/bindings/python/test_analyser.py b/tests/bindings/python/test_analyser.py index 856ea709d..4871b3e14 100644 --- a/tests/bindings/python/test_analyser.py +++ b/tests/bindings/python/test_analyser.py @@ -115,13 +115,13 @@ def test_coverage(self): self.assertIsNotNone(am.states()) self.assertIsNotNone(am.state(3)) - self.assertEqual(0, am.constantCount()) + self.assertEqual(5, am.constantCount()) self.assertIsNotNone(am.constants()) - self.assertIsNone(am.constant(3)) + self.assertIsNotNone(am.constant(3)) self.assertEqual(0, am.computedConstantCount()) self.assertIsNotNone(am.computedConstants()) self.assertIsNone(am.computedConstant(3)) - self.assertEqual(17, am.algebraicCount()) + self.assertEqual(12, am.algebraicCount()) self.assertIsNotNone(am.algebraic()) self.assertIsNotNone(am.algebraic(3)) @@ -160,15 +160,15 @@ def test_coverage(self): av = am.algebraic(3) - self.assertEqual(AnalyserVariable.Type.CONSTANT, av.type()) - self.assertEqual("constant", AnalyserVariable.typeAsString(av.type())) - self.assertEqual("constant", AnalyserVariable_typeAsString(av.type())) - self.assertEqual(0, av.index()) - self.assertIsNotNone(av.initialisingVariable()) + self.assertEqual(AnalyserVariable.Type.ALGEBRAIC, av.type()) + self.assertEqual("algebraic", AnalyserVariable.typeAsString(av.type())) + self.assertEqual("algebraic", AnalyserVariable_typeAsString(av.type())) + self.assertEqual(3, av.index()) + self.assertIsNone(av.initialisingVariable()) self.assertIsNotNone(av.variable()) self.assertEqual(1, av.equationCount()) self.assertIsNotNone(av.equations()) - self.assertIsNone(av.equation(0)) + self.assertIsNotNone(av.equation(0)) # Ensure coverage for AnalyserEquation. diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 83ce6b317..096e40b79 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -594,9 +594,9 @@ TEST(Coverage, generator) EXPECT_EQ("dae", libcellml::AnalyserModel::typeAsString(analyserModel->type())); EXPECT_EQ(size_t(1), analyserModel->stateCount()); - EXPECT_EQ(size_t(0), analyserModel->constantCount()); - EXPECT_EQ(size_t(0), analyserModel->computedConstantCount()); - EXPECT_EQ(size_t(209), analyserModel->algebraicCount()); + EXPECT_EQ(size_t(7), analyserModel->constantCount()); + EXPECT_EQ(size_t(200), analyserModel->computedConstantCount()); + EXPECT_EQ(size_t(2), analyserModel->algebraicCount()); EXPECT_EQ(size_t(203), analyserModel->equationCount()); EXPECT_NE(nullptr, analyserModel->voi()); @@ -608,9 +608,9 @@ TEST(Coverage, generator) EXPECT_NE(size_t(0), analyserModel->state(0)->equations().size()); EXPECT_NE(nullptr, analyserModel->state(0)->equation(0)); EXPECT_EQ(nullptr, analyserModel->state(analyserModel->stateCount())); - EXPECT_EQ(nullptr, analyserModel->constant(0)); + EXPECT_NE(nullptr, analyserModel->constant(0)); EXPECT_EQ(nullptr, analyserModel->constant(analyserModel->constantCount())); - EXPECT_EQ(nullptr, analyserModel->computedConstant(0)); + EXPECT_NE(nullptr, analyserModel->computedConstant(0)); EXPECT_EQ(nullptr, analyserModel->computedConstant(analyserModel->computedConstantCount())); EXPECT_NE(nullptr, analyserModel->algebraic(0)); EXPECT_EQ(nullptr, analyserModel->algebraic(analyserModel->algebraicCount())); @@ -652,27 +652,11 @@ TEST(Coverage, generator) } for (size_t i = 0; i < analyserModel->constantCount(); ++i) { - if ((i == 1) || (i == 2) || (i == 6) || (i == 18) || (i == 179) || (i == 180) || (i == 182) || (i == 205) || (i == 206)) { - EXPECT_TRUE(analyserModel->constant(i)->initialisingVariable() != nullptr); - } - } - - for (size_t i = 0; i < analyserModel->computedConstantCount(); ++i) { - if ((i == 1) || (i == 2) || (i == 6) || (i == 18) || (i == 179) || (i == 180) || (i == 182) || (i == 205) || (i == 206)) { - EXPECT_TRUE(analyserModel->computedConstant(i)->initialisingVariable() != nullptr); - } + EXPECT_NE(nullptr, analyserModel->constant(i)->initialisingVariable()); } for (size_t i = 0; i < analyserModel->algebraicCount(); ++i) { - if ((i == 1) || (i == 2) || (i == 6) || (i == 18) || (i == 179) || (i == 180) || (i == 182) || (i == 205) || (i == 206)) { - EXPECT_TRUE(analyserModel->algebraic(i)->initialisingVariable() != nullptr); - } - } - - for (size_t i = 0; i < analyserModel->externalCount(); ++i) { - if ((i == 1) || (i == 2) || (i == 6) || (i == 18) || (i == 179) || (i == 180) || (i == 182) || (i == 205) || (i == 206)) { - EXPECT_TRUE(analyserModel->external(i)->initialisingVariable() != nullptr); - } + EXPECT_NE(nullptr, analyserModel->algebraic(i)->initialisingVariable()); } EXPECT_EQ(nullptr, generator->model()); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index c6142792c..aa1b69f19 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 209; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 7; +const size_t COMPUTED_CONSTANT_COUNT = 200; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; @@ -21,13 +20,17 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"eqnEq", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"m", "dimensionless", "my_component", CONSTANT}, {"n", "dimensionless", "my_component", CONSTANT}, + {"o", "dimensionless", "my_component", CONSTANT}, + {"p", "dimensionless", "my_component", CONSTANT}, + {"q", "dimensionless", "my_component", CONSTANT}, + {"r", "dimensionless", "my_component", CONSTANT}, + {"s", "dimensionless", "my_component", CONSTANT}, + {"eqnEq", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnEqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnNeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnNeqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"o", "dimensionless", "my_component", CONSTANT}, {"eqnLt", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnLtCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnLeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, @@ -39,7 +42,6 @@ const VariableInfo VARIABLE_INFO[] = { {"eqnAnd", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnAndMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnAndParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"p", "dimensionless", "my_component", CONSTANT}, {"eqnAndParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnAndParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnAndParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, @@ -200,10 +202,7 @@ const VariableInfo VARIABLE_INFO[] = { {"eqnPiecewisePiece", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnPiecewisePieceOtherwise", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnPiecewisePiecePiecePiece", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"q", "dimensionless", "my_component", CONSTANT}, - {"r", "dimensionless", "my_component", CONSTANT}, {"eqnPiecewisePiecePiecePieceOtherwise", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"s", "dimensionless", "my_component", CONSTANT}, {"eqnWithPiecewise", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnCnInteger", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnCnDouble", "dimensionless", "my_component", COMPUTED_CONSTANT}, @@ -226,10 +225,10 @@ const VariableInfo VARIABLE_INFO[] = { {"eqnCoverageForPowerOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnCoverageForRootOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnCoverageForMinusUnary", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnNlaVariable1", "dimensionless", "my_component", ALGEBRAIC}, - {"eqnNlaVariable2", "dimensionless", "my_component", ALGEBRAIC}, {"eqnComputedConstant1", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnComputedConstant2", "dimensionless", "my_component", COMPUTED_CONSTANT} + {"eqnComputedConstant2", "dimensionless", "my_component", COMPUTED_CONSTANT}, + {"eqnNlaVariable1", "dimensionless", "my_component", ALGEBRAIC}, + {"eqnNlaVariable2", "dimensionless", "my_component", ALGEBRAIC} }; double xor(double x, double y) diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index c4835137a..e05872689 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 808684ff9..01e2454c3 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0.post0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 209; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 7; +const size_t COMPUTED_CONSTANT_COUNT = 200; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; @@ -21,13 +20,17 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"eqnEq", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"m", "dimensionless", "my_component", CONSTANT}, {"n", "dimensionless", "my_component", CONSTANT}, + {"o", "dimensionless", "my_component", CONSTANT}, + {"p", "dimensionless", "my_component", CONSTANT}, + {"q", "dimensionless", "my_component", CONSTANT}, + {"r", "dimensionless", "my_component", CONSTANT}, + {"s", "dimensionless", "my_component", CONSTANT}, + {"eqnEq", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnEqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnNeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnNeqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"o", "dimensionless", "my_component", CONSTANT}, {"eqnLt", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnLtCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnLeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, @@ -39,7 +42,6 @@ const VariableInfo VARIABLE_INFO[] = { {"eqnAnd", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnAndMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnAndParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"p", "dimensionless", "my_component", CONSTANT}, {"eqnAndParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnAndParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnAndParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, @@ -200,10 +202,7 @@ const VariableInfo VARIABLE_INFO[] = { {"eqnPiecewisePiece", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnPiecewisePieceOtherwise", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnPiecewisePiecePiecePiece", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"q", "dimensionless", "my_component", CONSTANT}, - {"r", "dimensionless", "my_component", CONSTANT}, {"eqnPiecewisePiecePiecePieceOtherwise", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"s", "dimensionless", "my_component", CONSTANT}, {"eqnWithPiecewise", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnCnInteger", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnCnDouble", "dimensionless", "my_component", COMPUTED_CONSTANT}, @@ -226,10 +225,10 @@ const VariableInfo VARIABLE_INFO[] = { {"eqnCoverageForPowerOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnCoverageForRootOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnCoverageForMinusUnary", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnNlaVariable1", "dimensionless", "my_component", ALGEBRAIC}, - {"eqnNlaVariable2", "dimensionless", "my_component", ALGEBRAIC}, {"eqnComputedConstant1", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnComputedConstant2", "dimensionless", "my_component", COMPUTED_CONSTANT} + {"eqnComputedConstant2", "dimensionless", "my_component", COMPUTED_CONSTANT}, + {"eqnNlaVariable1", "dimensionless", "my_component", ALGEBRAIC}, + {"eqnNlaVariable2", "dimensionless", "my_component", ALGEBRAIC} }; double xor(double x, double y) diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 08fc9fc5d..ef3a093e6 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 67d01e5cf..cd3746478 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 209 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 7 +COMPUTED_CONSTANT_COUNT = 200 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -29,13 +28,17 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "eqnEq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "m", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "n", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "o", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "p", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "q", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "r", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "s", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "eqnEq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnNeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnNeqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "o", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "eqnLt", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnLtCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnLeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, @@ -47,7 +50,6 @@ class VariableType(Enum): {"name": "eqnAnd", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnAndMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnAndParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "p", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "eqnAndParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnAndParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnAndParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, @@ -208,10 +210,7 @@ class VariableType(Enum): {"name": "eqnPiecewisePiece", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnPiecewisePieceOtherwise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnPiecewisePiecePiecePiece", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "q", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "r", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "eqnPiecewisePiecePiecePieceOtherwise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "s", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "eqnWithPiecewise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnCnInteger", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnCnDouble", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, @@ -234,10 +233,10 @@ class VariableType(Enum): {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC}, - {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC}, {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC}, + {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index ccf8c6706..07afa2a6b 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 209 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 7 +COMPUTED_CONSTANT_COUNT = 200 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -29,13 +28,17 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "eqnEq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "m", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "n", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "o", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "p", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "q", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "r", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "s", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "eqnEq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnNeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnNeqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "o", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "eqnLt", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnLtCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnLeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, @@ -47,7 +50,6 @@ class VariableType(Enum): {"name": "eqnAnd", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnAndMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnAndParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "p", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "eqnAndParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnAndParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnAndParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, @@ -208,10 +210,7 @@ class VariableType(Enum): {"name": "eqnPiecewisePiece", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnPiecewisePieceOtherwise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnPiecewisePiecePiecePiece", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "q", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "r", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "eqnPiecewisePiecePiecePieceOtherwise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "s", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "eqnWithPiecewise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnCnInteger", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnCnDouble", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, @@ -234,10 +233,10 @@ class VariableType(Enum): {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC}, - {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC}, {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC}, + {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index 7ad5b190a..ef4da021e 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -9,9 +9,8 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 2; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 665df9668..37cec86d3 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -10,8 +10,8 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 1; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_eqn", ALGEBRAIC}, diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 1d135a8d6..7168da1a3 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -9,8 +9,8 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 1 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index ffa08d417..8b9a1fb66 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -10,7 +10,6 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index a89a1f872..c3b91e3df 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -8,9 +8,8 @@ LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 2 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index a90730192..b9b36994d 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -8,14 +8,13 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { - {"x", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, - {"a", "dimensionless", "my_algebraic_eqn", CONSTANT} + {"a", "dimensionless", "my_algebraic_eqn", CONSTANT}, + {"x", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT} }; double * createVariablesArray() diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index ffa08d417..8b9a1fb66 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -10,7 +10,6 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index cac3a4142..034cacb34 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -7,10 +7,9 @@ __version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 1 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): @@ -20,8 +19,8 @@ class VariableType(Enum): VARIABLE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.CONSTANT} + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.CONSTANT}, + {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT} ] diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index b2142ca77..5e2571905 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -9,9 +9,8 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_component", COMPUTED_CONSTANT} diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index e5928a2fe..d26413c67 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -10,7 +10,6 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index e5238d296..b36b39ca8 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -8,9 +8,8 @@ LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 9cb7a3000..5f56854dd 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -10,9 +10,8 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index 02e634a29..1eeee2f1e 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index ed4157ad3..b68e0ff04 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -9,9 +9,8 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 75a65fe9c..4449ebc70 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -10,9 +10,8 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index 89890cfa6..ca79cc5f2 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 2e6d45e10..3228a39f5 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -9,9 +9,8 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index c6a0f3adf..32f1de15f 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -10,9 +10,8 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index 60658293a..d2a3025e3 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index fe2cececb..44baf1642 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -9,9 +9,8 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 2a8dbbed5..352e5bd87 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -10,9 +10,8 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "my_model", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index e98ffacdf..cfae2b1d2 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index a91cadb06..1a8d75e50 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -9,9 +9,8 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 75c1d28ae..78af0f1c1 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -9,9 +9,8 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 4; -const size_t EXTERNAL_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VARIABLE_INFO[] = { {"b", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index ce37e089b..5e1f7d6b8 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -9,9 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 4; -const size_t EXTERNAL_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_COUNT = 0; +const size_t EXTERNAL_COUNT = 1; const VariableInfo VARIABLE_INFO[] = { {"b", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 3998dee56..ed3205098 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -8,9 +8,9 @@ LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 4 -EXTERNAL_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_COUNT = 0 +EXTERNAL_COUNT = 1 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index ffa08d417..8b9a1fb66 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -10,7 +10,6 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index e823ec04a..1f349758b 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -8,9 +8,8 @@ LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 4 -EXTERNAL_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index 3fed4a9e1..eb6d409ad 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -11,7 +11,6 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 3; -const size_t EXTERNAL_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_system", ALGEBRAIC}, diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index fee170f4b..69ce3f676 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -10,7 +10,6 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 16bd44fe4..de50e042e 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -10,7 +10,6 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 3 -EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index 827f341f9..a22f00fad 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -10,8 +10,8 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 3; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; +const size_t EXTERNAL_COUNT = 3; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_algebraic_system", EXTERNAL}, diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index 0c3b6b4a5..7650d5f48 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -20,9 +20,9 @@ typedef enum { } VariableType; typedef struct { - char name[2]; - char units[14]; - char component[20]; + char name[0]; + char units[0]; + char component[0]; VariableType type; } VariableInfo; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index bdb2fe0fe..c79c81613 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -9,8 +9,8 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 3 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 0 +EXTERNAL_COUNT = 3 class VariableType(Enum): diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index c1b94c182..be81938b4 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -8,18 +8,17 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 6; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 2; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_COUNT = 3; const VariableInfo VARIABLE_INFO[] = { + {"x", "dimensionless", "my_algebraic_system", CONSTANT}, + {"y", "dimensionless", "my_algebraic_system", CONSTANT}, + {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT}, {"d", "dimensionless", "my_algebraic_system", ALGEBRAIC}, {"b", "dimensionless", "my_algebraic_system", ALGEBRAIC}, - {"c", "dimensionless", "my_algebraic_system", ALGEBRAIC}, - {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT}, - {"x", "dimensionless", "my_algebraic_system", CONSTANT}, - {"y", "dimensionless", "my_algebraic_system", CONSTANT} + {"c", "dimensionless", "my_algebraic_system", ALGEBRAIC} }; double * createVariablesArray() @@ -72,10 +71,10 @@ void findRoot0(double *variables) void initialiseVariables(double *constants) { - algebraic[1] = 1.0; - algebraic[2] = 1.0; constants[0] = 3.0; constants[1] = 5.0; + algebraic[1] = 1.0; + algebraic[2] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index fee170f4b..69ce3f676 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -10,7 +10,6 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 8a734a9a3..a10c6ed59 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -7,10 +7,9 @@ __version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 6 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 2 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_COUNT = 3 class VariableType(Enum): @@ -20,12 +19,12 @@ class VariableType(Enum): VARIABLE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT}, + {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT}, + {"name": "a", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.COMPUTED_CONSTANT}, {"name": "d", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, {"name": "b", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, - {"name": "c", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, - {"name": "a", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT}, - {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT} + {"name": "c", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC} ] @@ -59,10 +58,10 @@ def find_root_0(variables): def initialise_variables(constants): - algebraic[1] = 1.0 - algebraic[2] = 1.0 constants[0] = 3.0 constants[1] = 5.0 + algebraic[1] = 1.0 + algebraic[2] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index 15de97b49..df91e1567 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -8,15 +8,14 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 6; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 2; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_COUNT = 3; const VariableInfo VARIABLE_INFO[] = { - {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT}, {"x", "dimensionless", "my_algebraic_system", CONSTANT}, {"y", "dimensionless", "my_algebraic_system", CONSTANT}, + {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT}, {"c", "dimensionless", "my_algebraic_system", ALGEBRAIC}, {"b", "dimensionless", "my_algebraic_system", ALGEBRAIC}, {"d", "dimensionless", "my_algebraic_system", ALGEBRAIC} diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index fee170f4b..69ce3f676 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -10,7 +10,6 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index e842a7e56..3272ba839 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -7,10 +7,9 @@ __version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 6 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 2 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_COUNT = 3 class VariableType(Enum): @@ -20,9 +19,9 @@ class VariableType(Enum): VARIABLE_INFO = [ - {"name": "a", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.COMPUTED_CONSTANT}, {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT}, {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT}, + {"name": "a", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.COMPUTED_CONSTANT}, {"name": "c", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, {"name": "b", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, {"name": "d", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC} diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index 0fab3f892..bfdee7fae 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -9,9 +9,8 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 2; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"x", "dimensionless", "my_component", COMPUTED_CONSTANT}, diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index e5928a2fe..d26413c67 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -10,7 +10,6 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 53f8993bf..020c15fc0 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -8,9 +8,8 @@ LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 2 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index e6391bb73..1d2073048 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -8,15 +8,14 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 4; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 2; +const size_t COMPUTED_CONSTANT_COUNT = 2; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { - {"vcell", "microlitre", "cell_geometry", COMPUTED_CONSTANT}, {"L", "centimeter", "cell_geometry", CONSTANT}, {"rad", "centimeter", "cell_geometry", CONSTANT}, + {"vcell", "microlitre", "cell_geometry", COMPUTED_CONSTANT}, {"vss", "microlitre", "cell_geometry", COMPUTED_CONSTANT} }; diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 8ecb305e9..4fe760dd4 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -10,14 +10,14 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 4; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 2; const VariableInfo VARIABLE_INFO[] = { {"vcell", "microlitre", "cell_geometry", ALGEBRAIC}, + {"vss", "microlitre", "cell_geometry", ALGEBRAIC}, {"L", "centimeter", "cell_geometry", EXTERNAL}, - {"rad", "centimeter", "cell_geometry", EXTERNAL}, - {"vss", "microlitre", "cell_geometry", ALGEBRAIC} + {"rad", "centimeter", "cell_geometry", EXTERNAL} }; double * createVariablesArray() diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 2bf7fb613..4c1af8bb9 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -9,8 +9,8 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 4 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 2 class VariableType(Enum): @@ -22,9 +22,9 @@ class VariableType(Enum): VARIABLE_INFO = [ {"name": "vcell", "units": "microlitre", "component": "cell_geometry", "type": VariableType.ALGEBRAIC}, + {"name": "vss", "units": "microlitre", "component": "cell_geometry", "type": VariableType.ALGEBRAIC}, {"name": "L", "units": "centimeter", "component": "cell_geometry", "type": VariableType.EXTERNAL}, - {"name": "rad", "units": "centimeter", "component": "cell_geometry", "type": VariableType.EXTERNAL}, - {"name": "vss", "units": "microlitre", "component": "cell_geometry", "type": VariableType.ALGEBRAIC} + {"name": "rad", "units": "centimeter", "component": "cell_geometry", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index ef37e5ea5..d291cbc39 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -10,7 +10,6 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index eb269347e..b25e428a5 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -7,10 +7,9 @@ __version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 4 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 2 +COMPUTED_CONSTANT_COUNT = 2 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): @@ -20,9 +19,9 @@ class VariableType(Enum): VARIABLE_INFO = [ - {"name": "vcell", "units": "microlitre", "component": "cell_geometry", "type": VariableType.COMPUTED_CONSTANT}, {"name": "L", "units": "centimeter", "component": "cell_geometry", "type": VariableType.CONSTANT}, {"name": "rad", "units": "centimeter", "component": "cell_geometry", "type": VariableType.CONSTANT}, + {"name": "vcell", "units": "microlitre", "component": "cell_geometry", "type": VariableType.COMPUTED_CONSTANT}, {"name": "vss", "units": "microlitre", "component": "cell_geometry", "type": VariableType.COMPUTED_CONSTANT} ] diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 92bf0a4fb..3f59baaf8 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -12,7 +12,6 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index 2aab41a47..91a2bbdb9 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 8ecaaaaa4..42799d811 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -11,7 +11,6 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index 5ffe3d04e..b03cf8648 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -7,10 +7,9 @@ __version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 10 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 9 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): @@ -20,7 +19,6 @@ class VariableType(Enum): VARIABLE_INFO = [ - {"name": "v", "units": "fmol_per_sec", "component": "SLC_template3_ss", "type": VariableType.COMPUTED_CONSTANT}, {"name": "E", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "q_Ao", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, @@ -29,7 +27,8 @@ class VariableType(Enum): {"name": "P_2", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT} + {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, + {"name": "v", "units": "fmol_per_sec", "component": "SLC_template3_ss", "type": VariableType.COMPUTED_CONSTANT} ] diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index 88193e176..e8e13541c 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index 1a5d4ce25..e95d12eb1 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index ff1defc39..5aae09a47 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 616edc403..21638fba9 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -8,10 +8,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 3; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 2; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VARIABLE_INFO[] = { {"k", "mM", "constants", CONSTANT}, diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index ed21d6473..435deb74f 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -10,7 +10,6 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { CONSTANT, diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index 6cd14b1a9..d2ee195c5 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -7,10 +7,9 @@ __version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 3 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 1 +COMPUTED_CONSTANT_COUNT = 2 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 87f36e81d..603a1eab3 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -12,7 +12,6 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index 1a5d4ce25..e95d12eb1 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 572138bfc..f74588e12 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -11,7 +11,6 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 0e2889515..34c1bca1f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -12,7 +12,6 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index 1a5d4ce25..e95d12eb1 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index ea1dd2f48..ec43146e3 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -11,7 +11,6 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index 9689d4fc9..c0db3b3a3 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -12,7 +12,6 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index fe3771382..bd4dd923e 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index 214d36e3f..86e48a995 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -11,7 +11,6 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 -EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index cf6cc5619..27bf38fab 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 2; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 480606249..fc9911e7e 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 084fde5b2..9e1edd3c4 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 2 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index 022b4ee5a..f0e1d42ba 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -12,7 +12,6 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index cc72c5b3a..3f1fb63fd 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index 8f5a9954f..e14df017f 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -11,7 +11,6 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 -EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index 37a9e4aa4..cd6840c59 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -12,7 +12,6 @@ const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 2c159313c..123e68564 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index fbb32f6af..ac4a5b309 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -11,7 +11,6 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 -EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 91a85192a..3b8e5e3bc 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 10; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 5; const VariableInfo VOI_INFO = {"t", "second", "main", VARIABLE_OF_INTEGRATION}; @@ -22,16 +21,16 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"v_1", "C_per_s", "main", ALGEBRAIC}, {"v_in", "C_per_s", "main", CONSTANT}, - {"v_2", "C_per_s", "main", ALGEBRAIC}, {"v_out", "C_per_s", "main", CONSTANT}, - {"u_1", "J_per_C", "main", ALGEBRAIC}, - {"u_2", "J_per_C", "main", ALGEBRAIC}, - {"u_3", "J_per_C", "main", ALGEBRAIC}, {"C", "C2_per_J", "main", CONSTANT}, {"R", "Js_per_C2", "main", CONSTANT}, - {"L", "Js2_per_C2", "main", CONSTANT} + {"L", "Js2_per_C2", "main", CONSTANT}, + {"v_1", "C_per_s", "main", ALGEBRAIC}, + {"v_2", "C_per_s", "main", ALGEBRAIC}, + {"u_1", "J_per_C", "main", ALGEBRAIC}, + {"u_2", "J_per_C", "main", ALGEBRAIC}, + {"u_3", "J_per_C", "main", ALGEBRAIC} }; double * createStatesArray() @@ -121,13 +120,13 @@ void findRoot1(double voi, double *states, double *rates, double *variables) void initialiseVariables(double *states, double *rates, double *constants) { - algebraic[0] = 0.0; constants[0] = 1.0; constants[1] = 1.0; - algebraic[4] = 0.0; constants[2] = 20.0; constants[3] = 2.0; constants[4] = 10.0; + algebraic[0] = 0.0; + algebraic[4] = 0.0; states[0] = 1.0; states[1] = 0.0; } diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 12391c848..2bcb43579 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index c08f81990..50658a4db 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 10 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 5 class VariableType(Enum): @@ -30,16 +29,16 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "v_1", "units": "C_per_s", "component": "main", "type": VariableType.ALGEBRAIC}, {"name": "v_in", "units": "C_per_s", "component": "main", "type": VariableType.CONSTANT}, - {"name": "v_2", "units": "C_per_s", "component": "main", "type": VariableType.ALGEBRAIC}, {"name": "v_out", "units": "C_per_s", "component": "main", "type": VariableType.CONSTANT}, - {"name": "u_1", "units": "J_per_C", "component": "main", "type": VariableType.ALGEBRAIC}, - {"name": "u_2", "units": "J_per_C", "component": "main", "type": VariableType.ALGEBRAIC}, - {"name": "u_3", "units": "J_per_C", "component": "main", "type": VariableType.ALGEBRAIC}, {"name": "C", "units": "C2_per_J", "component": "main", "type": VariableType.CONSTANT}, {"name": "R", "units": "Js_per_C2", "component": "main", "type": VariableType.CONSTANT}, - {"name": "L", "units": "Js2_per_C2", "component": "main", "type": VariableType.CONSTANT} + {"name": "L", "units": "Js2_per_C2", "component": "main", "type": VariableType.CONSTANT}, + {"name": "v_1", "units": "C_per_s", "component": "main", "type": VariableType.ALGEBRAIC}, + {"name": "v_2", "units": "C_per_s", "component": "main", "type": VariableType.ALGEBRAIC}, + {"name": "u_1", "units": "J_per_C", "component": "main", "type": VariableType.ALGEBRAIC}, + {"name": "u_2", "units": "J_per_C", "component": "main", "type": VariableType.ALGEBRAIC}, + {"name": "u_3", "units": "J_per_C", "component": "main", "type": VariableType.ALGEBRAIC} ] @@ -97,13 +96,13 @@ def find_root_1(voi, states, rates, variables): def initialise_variables(states, rates, constants): - algebraic[0] = 0.0 constants[0] = 1.0 constants[1] = 1.0 - algebraic[4] = 0.0 constants[2] = 20.0 constants[3] = 2.0 constants[4] = 10.0 + algebraic[0] = 0.0 + algebraic[4] = 0.0 states[0] = 1.0 states[1] = 0.0 diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 8afaa994e..7bbb98144 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -12,7 +12,6 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"time", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index bfb9e7234..676c75fec 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index 9f9268732..5ed89e910 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -11,7 +11,6 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 839f56874..0e25bc096 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 33; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 217; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 91; +const size_t COMPUTED_CONSTANT_COUNT = 25; +const size_t ALGEBRAIC_COUNT = 101; const VariableInfo VOI_INFO = {"time", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -55,47 +54,20 @@ const VariableInfo STATE_INFO[] = { const VariableInfo VARIABLE_INFO[] = { {"ACh", "millimolar", "Rate_modulation_experiments", CONSTANT}, {"Iso_1_uM", "dimensionless", "Rate_modulation_experiments", CONSTANT}, - {"E_Na", "millivolt", "Ionic_values", ALGEBRAIC}, - {"RTONF", "millivolt", "Membrane", COMPUTED_CONSTANT}, {"Nao", "millimolar", "Ionic_values", CONSTANT}, - {"Nai", "millimolar", "Nai_concentration", ALGEBRAIC}, - {"E_K", "millivolt", "Ionic_values", COMPUTED_CONSTANT}, {"Ko", "millimolar", "Ionic_values", CONSTANT}, {"Ki", "millimolar", "Ionic_values", CONSTANT}, - {"E_Ca", "millivolt", "Ionic_values", ALGEBRAIC}, {"Cao", "millimolar", "Ionic_values", CONSTANT}, {"Nai_clamp", "dimensionless", "Nai_concentration", CONSTANT}, - {"i_Na", "nanoA", "i_Na", ALGEBRAIC}, - {"i_NaCa", "nanoA", "i_NaCa", ALGEBRAIC}, - {"i_NaK", "nanoA", "i_NaK", ALGEBRAIC}, - {"i_siNa", "nanoA", "i_CaL", ALGEBRAIC}, - {"i_fNa", "nanoA", "i_f", ALGEBRAIC}, {"F", "coulomb_per_mole", "Membrane", CONSTANT}, - {"V_i", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, - {"V_sub", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, - {"Iso_increase", "dimensionless", "i_NaK", COMPUTED_CONSTANT}, - {"V", "millivolt", "Membrane", ALGEBRAIC}, {"Km_Nap", "millimolar", "i_NaK", CONSTANT}, {"Km_Kp", "millimolar", "i_NaK", CONSTANT}, {"i_NaK_max", "nanoA", "i_NaK", CONSTANT}, {"blockade_NaCa", "dimensionless", "i_NaCa", CONSTANT}, - {"x2", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k21", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"x1", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k12", "dimensionless", "i_NaCa", ALGEBRAIC}, {"K_NaCa", "nanoA", "i_NaCa", CONSTANT}, - {"x4", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"x3", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k41", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k23", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k34", "dimensionless", "i_NaCa", COMPUTED_CONSTANT}, - {"k43", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k32", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k14", "dimensionless", "i_NaCa", ALGEBRAIC}, {"K3ni", "millimolar", "i_NaCa", CONSTANT}, {"Kci", "millimolar", "i_NaCa", CONSTANT}, {"Qci", "dimensionless", "i_NaCa", CONSTANT}, - {"di", "dimensionless", "i_NaCa", ALGEBRAIC}, {"K1ni", "millimolar", "i_NaCa", CONSTANT}, {"K2ni", "millimolar", "i_NaCa", CONSTANT}, {"Qn", "dimensionless", "i_NaCa", CONSTANT}, @@ -103,152 +75,185 @@ const VariableInfo VARIABLE_INFO[] = { {"K3no", "millimolar", "i_NaCa", CONSTANT}, {"Kco", "millimolar", "i_NaCa", CONSTANT}, {"Qco", "dimensionless", "i_NaCa", CONSTANT}, - {"do", "dimensionless", "i_NaCa", ALGEBRAIC}, {"K1no", "millimolar", "i_NaCa", CONSTANT}, {"K2no", "millimolar", "i_NaCa", CONSTANT}, - {"j_SRCarel", "millimolar_per_second", "Ca_SR_release", ALGEBRAIC}, {"ks", "per_second", "Ca_SR_release", CONSTANT}, - {"diff", "millimolar", "Ca_SR_release", ALGEBRAIC}, - {"kCaSR", "dimensionless", "Ca_SR_release", ALGEBRAIC}, {"MaxSR", "dimensionless", "Ca_SR_release", CONSTANT}, {"MinSR", "dimensionless", "Ca_SR_release", CONSTANT}, {"EC50_SR", "millimolar", "Ca_SR_release", CONSTANT}, {"HSR", "dimensionless", "Ca_SR_release", CONSTANT}, - {"koSRCa", "per_millimolar2_second", "Ca_SR_release", ALGEBRAIC}, {"koCa", "per_millimolar2_second", "Ca_SR_release", CONSTANT}, - {"kiSRCa", "per_millimolar_second", "Ca_SR_release", ALGEBRAIC}, {"kiCa", "per_millimolar_second", "Ca_SR_release", CONSTANT}, {"kim", "per_second", "Ca_SR_release", CONSTANT}, {"kom", "per_second", "Ca_SR_release", CONSTANT}, - {"P_tot", "dimensionless", "Ca_SR_release", ALGEBRAIC}, - {"b_up", "dimensionless", "Ca_intracellular_fluxes", COMPUTED_CONSTANT}, - {"P_up", "millimolar_per_second", "Ca_intracellular_fluxes", COMPUTED_CONSTANT}, {"P_up_basal", "millimolar_per_second", "Ca_intracellular_fluxes", CONSTANT}, - {"j_Ca_dif", "millimolar_per_second", "Ca_intracellular_fluxes", ALGEBRAIC}, {"tau_dif_Ca", "second", "Ca_intracellular_fluxes", CONSTANT}, - {"j_up", "millimolar_per_second", "Ca_intracellular_fluxes", ALGEBRAIC}, {"K_up", "millimolar", "Ca_intracellular_fluxes", CONSTANT}, {"slope_up", "millimolar", "Ca_intracellular_fluxes", CONSTANT}, - {"j_tr", "millimolar_per_second", "Ca_intracellular_fluxes", ALGEBRAIC}, {"tau_tr", "second", "Ca_intracellular_fluxes", CONSTANT}, - {"delta_fTC", "per_second", "Ca_buffering", ALGEBRAIC}, {"kf_TC", "per_millimolar_second", "Ca_buffering", CONSTANT}, {"kb_TC", "per_second", "Ca_buffering", CONSTANT}, - {"delta_fTMC", "per_second", "Ca_buffering", ALGEBRAIC}, {"kf_TMC", "per_millimolar_second", "Ca_buffering", CONSTANT}, {"kb_TMC", "per_second", "Ca_buffering", CONSTANT}, - {"delta_fTMM", "per_second", "Ca_buffering", ALGEBRAIC}, {"kf_TMM", "per_millimolar_second", "Ca_buffering", CONSTANT}, {"Mgi", "millimolar", "Ca_buffering", CONSTANT}, {"kb_TMM", "per_second", "Ca_buffering", CONSTANT}, - {"delta_fCMi", "per_second", "Ca_buffering", ALGEBRAIC}, {"kf_CM", "per_millimolar_second", "Ca_buffering", CONSTANT}, {"kb_CM", "per_second", "Ca_buffering", CONSTANT}, - {"delta_fCMs", "per_second", "Ca_buffering", ALGEBRAIC}, - {"delta_fCQ", "per_second", "Ca_buffering", ALGEBRAIC}, {"kf_CQ", "per_millimolar_second", "Ca_buffering", CONSTANT}, {"kb_CQ", "per_second", "Ca_buffering", CONSTANT}, {"TC_tot", "millimolar", "Ca_buffering", CONSTANT}, {"TMC_tot", "millimolar", "Ca_buffering", CONSTANT}, {"CM_tot", "millimolar", "Ca_buffering", CONSTANT}, {"CQ_tot", "millimolar", "Ca_buffering", CONSTANT}, - {"V_nsr", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, - {"V_jsr", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, - {"i_siCa", "nanoA", "i_CaL", ALGEBRAIC}, - {"i_CaT", "nanoA", "i_CaT", ALGEBRAIC}, - {"V_cell", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, {"L_cell", "micrometre", "Cell_parameters", CONSTANT}, {"R_cell", "micrometre", "Cell_parameters", CONSTANT}, {"L_sub", "micrometre", "Cell_parameters", CONSTANT}, {"V_jsr_part", "dimensionless", "Cell_parameters", CONSTANT}, {"V_i_part", "dimensionless", "Cell_parameters", CONSTANT}, {"V_nsr_part", "dimensionless", "Cell_parameters", CONSTANT}, - {"i_tot", "nanoA", "Membrane", ALGEBRAIC}, - {"i_f", "nanoA", "i_f", ALGEBRAIC}, - {"i_Kur", "nanoA", "i_Kur", ALGEBRAIC}, - {"i_KACh", "nanoA", "i_KACh", ALGEBRAIC}, - {"i_CaL", "nanoA", "i_CaL", ALGEBRAIC}, - {"i_to", "nanoA", "i_to", ALGEBRAIC}, - {"i_Ks", "nanoA", "i_Ks", ALGEBRAIC}, - {"i_Kr", "nanoA", "i_Kr", ALGEBRAIC}, {"C", "microF", "Membrane", CONSTANT}, {"R", "joule_per_kilomole_kelvin", "Membrane", CONSTANT}, {"T", "kelvin", "Membrane", CONSTANT}, - {"V_clamp", "millivolt", "Voltage_clamp", ALGEBRAIC}, {"clamp_mode", "dimensionless", "Membrane", CONSTANT}, {"V_test", "millivolt", "Voltage_clamp", CONSTANT}, {"t_holding", "second", "Voltage_clamp", CONSTANT}, {"t_test", "second", "Voltage_clamp", CONSTANT}, {"V_holding", "millivolt", "Voltage_clamp", CONSTANT}, - {"G_f", "microS", "i_f", COMPUTED_CONSTANT}, {"g_f", "microS", "i_f", CONSTANT}, {"Km_f", "millimolar", "i_f", CONSTANT}, - {"G_f_K", "microS", "i_f", COMPUTED_CONSTANT}, {"alpha", "dimensionless", "i_f", CONSTANT}, + {"blockade", "dimensionless", "i_f", CONSTANT}, + {"y_shift", "millivolt", "i_f_y_gate", CONSTANT}, + {"g_Na", "microS", "i_Na", CONSTANT}, + {"g_Na_L", "microS", "i_Na", CONSTANT}, + {"delta_m", "millivolt", "i_Na_m_gate", CONSTANT}, + {"g_Kur", "microS", "i_Kur", CONSTANT}, + {"P_CaL", "nanoA_per_millimolar", "i_CaL", CONSTANT}, + {"V_dL", "millivolt", "i_CaL_dL_gate", CONSTANT}, + {"k_dL", "millivolt", "i_CaL_dL_gate", CONSTANT}, + {"shift_fL", "millivolt", "i_CaL_fL_gate", CONSTANT}, + {"k_fL", "millivolt", "i_CaL_fL_gate", CONSTANT}, + {"Km_fCa", "millimolar", "i_CaL_fCa_gate", CONSTANT}, + {"alpha_fCa", "per_second", "i_CaL_fCa_gate", CONSTANT}, + {"P_CaT", "nanoA_per_millimolar", "i_CaT", CONSTANT}, + {"offset_fT", "second", "i_CaT_fT_gate", CONSTANT}, + {"g_to", "microS", "i_to", CONSTANT}, + {"g_Kr", "microS", "i_Kr", CONSTANT}, + {"g_Ks_", "microS", "i_Ks", CONSTANT}, + {"ACh_on", "dimensionless", "i_KACh", CONSTANT}, + {"g_KACh", "microS", "i_KACh", CONSTANT}, + {"RTONF", "millivolt", "Membrane", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "Ionic_values", COMPUTED_CONSTANT}, + {"V_i", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, + {"V_sub", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, + {"Iso_increase", "dimensionless", "i_NaK", COMPUTED_CONSTANT}, + {"k34", "dimensionless", "i_NaCa", COMPUTED_CONSTANT}, + {"b_up", "dimensionless", "Ca_intracellular_fluxes", COMPUTED_CONSTANT}, + {"P_up", "millimolar_per_second", "Ca_intracellular_fluxes", COMPUTED_CONSTANT}, + {"V_nsr", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, + {"V_jsr", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, + {"V_cell", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, + {"G_f", "microS", "i_f", COMPUTED_CONSTANT}, + {"G_f_K", "microS", "i_f", COMPUTED_CONSTANT}, {"G_f_Na", "microS", "i_f", COMPUTED_CONSTANT}, {"g_f_Na", "microS", "i_f", COMPUTED_CONSTANT}, {"g_f_K", "microS", "i_f", COMPUTED_CONSTANT}, - {"blockade", "dimensionless", "i_f", CONSTANT}, - {"i_fK", "nanoA", "i_f", ALGEBRAIC}, {"ACh_shift", "millivolt", "i_f_y_gate", COMPUTED_CONSTANT}, {"Iso_shift", "millivolt", "i_f_y_gate", COMPUTED_CONSTANT}, + {"Iso_increase", "dimensionless", "i_CaL", COMPUTED_CONSTANT}, + {"ACh_block", "dimensionless", "i_CaL", COMPUTED_CONSTANT}, + {"Iso_shift_dL", "millivolt", "i_CaL_dL_gate", COMPUTED_CONSTANT}, + {"Iso_slope_dL", "dimensionless", "i_CaL_dL_gate", COMPUTED_CONSTANT}, + {"g_Ks", "microS", "i_Ks", COMPUTED_CONSTANT}, + {"Iso_shift", "millivolt", "i_Ks_n_gate", COMPUTED_CONSTANT}, + {"alpha_a", "per_second", "i_KACh_a_gate", COMPUTED_CONSTANT}, + {"E_Na", "millivolt", "Ionic_values", ALGEBRAIC}, + {"Nai", "millimolar", "Nai_concentration", ALGEBRAIC}, + {"E_Ca", "millivolt", "Ionic_values", ALGEBRAIC}, + {"i_Na", "nanoA", "i_Na", ALGEBRAIC}, + {"i_NaCa", "nanoA", "i_NaCa", ALGEBRAIC}, + {"i_NaK", "nanoA", "i_NaK", ALGEBRAIC}, + {"i_siNa", "nanoA", "i_CaL", ALGEBRAIC}, + {"i_fNa", "nanoA", "i_f", ALGEBRAIC}, + {"V", "millivolt", "Membrane", ALGEBRAIC}, + {"x2", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"k21", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"x1", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"k12", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"x4", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"x3", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"k41", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"k23", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"k43", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"k32", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"k14", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"di", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"do", "dimensionless", "i_NaCa", ALGEBRAIC}, + {"j_SRCarel", "millimolar_per_second", "Ca_SR_release", ALGEBRAIC}, + {"diff", "millimolar", "Ca_SR_release", ALGEBRAIC}, + {"kCaSR", "dimensionless", "Ca_SR_release", ALGEBRAIC}, + {"koSRCa", "per_millimolar2_second", "Ca_SR_release", ALGEBRAIC}, + {"kiSRCa", "per_millimolar_second", "Ca_SR_release", ALGEBRAIC}, + {"P_tot", "dimensionless", "Ca_SR_release", ALGEBRAIC}, + {"j_Ca_dif", "millimolar_per_second", "Ca_intracellular_fluxes", ALGEBRAIC}, + {"j_up", "millimolar_per_second", "Ca_intracellular_fluxes", ALGEBRAIC}, + {"j_tr", "millimolar_per_second", "Ca_intracellular_fluxes", ALGEBRAIC}, + {"delta_fTC", "per_second", "Ca_buffering", ALGEBRAIC}, + {"delta_fTMC", "per_second", "Ca_buffering", ALGEBRAIC}, + {"delta_fTMM", "per_second", "Ca_buffering", ALGEBRAIC}, + {"delta_fCMi", "per_second", "Ca_buffering", ALGEBRAIC}, + {"delta_fCMs", "per_second", "Ca_buffering", ALGEBRAIC}, + {"delta_fCQ", "per_second", "Ca_buffering", ALGEBRAIC}, + {"i_siCa", "nanoA", "i_CaL", ALGEBRAIC}, + {"i_CaT", "nanoA", "i_CaT", ALGEBRAIC}, + {"i_tot", "nanoA", "Membrane", ALGEBRAIC}, + {"i_f", "nanoA", "i_f", ALGEBRAIC}, + {"i_Kur", "nanoA", "i_Kur", ALGEBRAIC}, + {"i_KACh", "nanoA", "i_KACh", ALGEBRAIC}, + {"i_CaL", "nanoA", "i_CaL", ALGEBRAIC}, + {"i_to", "nanoA", "i_to", ALGEBRAIC}, + {"i_Ks", "nanoA", "i_Ks", ALGEBRAIC}, + {"i_Kr", "nanoA", "i_Kr", ALGEBRAIC}, + {"V_clamp", "millivolt", "Voltage_clamp", ALGEBRAIC}, + {"i_fK", "nanoA", "i_f", ALGEBRAIC}, {"tau_y", "second", "i_f_y_gate", ALGEBRAIC}, {"y_infinity", "dimensionless", "i_f_y_gate", ALGEBRAIC}, - {"y_shift", "millivolt", "i_f_y_gate", CONSTANT}, {"E_mh", "millivolt", "i_Na", ALGEBRAIC}, {"i_Na_", "nanoA", "i_Na", ALGEBRAIC}, - {"g_Na", "microS", "i_Na", CONSTANT}, {"i_Na_L", "nanoA", "i_Na", ALGEBRAIC}, - {"g_Na_L", "microS", "i_Na", CONSTANT}, {"m_infinity", "dimensionless", "i_Na_m_gate", ALGEBRAIC}, {"E0_m", "millivolt", "i_Na_m_gate", ALGEBRAIC}, {"alpha_m", "per_second", "i_Na_m_gate", ALGEBRAIC}, - {"delta_m", "millivolt", "i_Na_m_gate", CONSTANT}, {"beta_m", "per_second", "i_Na_m_gate", ALGEBRAIC}, {"tau_m", "second", "i_Na_m_gate", ALGEBRAIC}, {"h_infinity", "dimensionless", "i_Na_h_gate", ALGEBRAIC}, {"alpha_h", "per_second", "i_Na_h_gate", ALGEBRAIC}, {"beta_h", "per_second", "i_Na_h_gate", ALGEBRAIC}, {"tau_h", "second", "i_Na_h_gate", ALGEBRAIC}, - {"g_Kur", "microS", "i_Kur", CONSTANT}, {"r_Kur_infinity", "dimensionless", "i_Kur_rKur_gate", ALGEBRAIC}, {"tau_r_Kur", "second", "i_Kur_rKur_gate", ALGEBRAIC}, {"s_Kur_infinity", "dimensionless", "i_Kur_sKur_gate", ALGEBRAIC}, {"tau_s_Kur", "second", "i_Kur_sKur_gate", ALGEBRAIC}, - {"Iso_increase", "dimensionless", "i_CaL", COMPUTED_CONSTANT}, - {"P_CaL", "nanoA_per_millimolar", "i_CaL", CONSTANT}, {"i_siK", "nanoA", "i_CaL", ALGEBRAIC}, - {"ACh_block", "dimensionless", "i_CaL", COMPUTED_CONSTANT}, - {"Iso_shift_dL", "millivolt", "i_CaL_dL_gate", COMPUTED_CONSTANT}, - {"Iso_slope_dL", "dimensionless", "i_CaL_dL_gate", COMPUTED_CONSTANT}, {"dL_infinity", "dimensionless", "i_CaL_dL_gate", ALGEBRAIC}, - {"V_dL", "millivolt", "i_CaL_dL_gate", CONSTANT}, - {"k_dL", "millivolt", "i_CaL_dL_gate", CONSTANT}, {"tau_dL", "second", "i_CaL_dL_gate", ALGEBRAIC}, {"alpha_dL", "per_second", "i_CaL_dL_gate", ALGEBRAIC}, {"beta_dL", "per_second", "i_CaL_dL_gate", ALGEBRAIC}, {"adVm", "millivolt", "i_CaL_dL_gate", ALGEBRAIC}, {"bdVm", "millivolt", "i_CaL_dL_gate", ALGEBRAIC}, {"fL_infinity", "dimensionless", "i_CaL_fL_gate", ALGEBRAIC}, - {"shift_fL", "millivolt", "i_CaL_fL_gate", CONSTANT}, - {"k_fL", "millivolt", "i_CaL_fL_gate", CONSTANT}, {"tau_fL", "second", "i_CaL_fL_gate", ALGEBRAIC}, {"fCa_infinity", "dimensionless", "i_CaL_fCa_gate", ALGEBRAIC}, - {"Km_fCa", "millimolar", "i_CaL_fCa_gate", CONSTANT}, {"tau_fCa", "second", "i_CaL_fCa_gate", ALGEBRAIC}, - {"alpha_fCa", "per_second", "i_CaL_fCa_gate", CONSTANT}, - {"P_CaT", "nanoA_per_millimolar", "i_CaT", CONSTANT}, {"dT_infinity", "dimensionless", "i_CaT_dT_gate", ALGEBRAIC}, {"tau_dT", "second", "i_CaT_dT_gate", ALGEBRAIC}, {"fT_infinity", "dimensionless", "i_CaT_fT_gate", ALGEBRAIC}, {"tau_fT", "second", "i_CaT_fT_gate", ALGEBRAIC}, - {"offset_fT", "second", "i_CaT_fT_gate", CONSTANT}, - {"g_to", "microS", "i_to", CONSTANT}, {"q_infinity", "dimensionless", "i_to_q_gate", ALGEBRAIC}, {"tau_q", "second", "i_to_q_gate", ALGEBRAIC}, {"r_infinity", "dimensionless", "i_to_r_gate", ALGEBRAIC}, {"tau_r", "second", "i_to_r_gate", ALGEBRAIC}, - {"g_Kr", "microS", "i_Kr", CONSTANT}, {"alfapaF", "per_second", "i_Kr_pa_gate", ALGEBRAIC}, {"betapaF", "per_second", "i_Kr_pa_gate", ALGEBRAIC}, {"pa_infinity", "dimensionless", "i_Kr_pa_gate", ALGEBRAIC}, @@ -256,17 +261,11 @@ const VariableInfo VARIABLE_INFO[] = { {"tau_paF", "second", "i_Kr_pa_gate", ALGEBRAIC}, {"tau_pi", "second", "i_Kr_pi_gate", ALGEBRAIC}, {"pi_infinity", "dimensionless", "i_Kr_pi_gate", ALGEBRAIC}, - {"g_Ks", "microS", "i_Ks", COMPUTED_CONSTANT}, - {"g_Ks_", "microS", "i_Ks", CONSTANT}, {"E_Ks", "millivolt", "i_Ks", ALGEBRAIC}, - {"Iso_shift", "millivolt", "i_Ks_n_gate", COMPUTED_CONSTANT}, {"n_infinity", "dimensionless", "i_Ks_n_gate", ALGEBRAIC}, {"tau_n", "second", "i_Ks_n_gate", ALGEBRAIC}, {"alpha_n", "per_second", "i_Ks_n_gate", ALGEBRAIC}, {"beta_n", "per_second", "i_Ks_n_gate", ALGEBRAIC}, - {"ACh_on", "dimensionless", "i_KACh", CONSTANT}, - {"g_KACh", "microS", "i_KACh", CONSTANT}, - {"alpha_a", "per_second", "i_KACh_a_gate", COMPUTED_CONSTANT}, {"beta_a", "per_second", "i_KACh_a_gate", ALGEBRAIC}, {"a_infinity", "dimensionless", "i_KACh_a_gate", ALGEBRAIC}, {"tau_a", "second", "i_KACh_a_gate", ALGEBRAIC} diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 72e65f564..e94e9dec0 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index bf46049b2..413cd1d94 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 33 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 217 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 91 +COMPUTED_CONSTANT_COUNT = 25 +ALGEBRAIC_COUNT = 101 class VariableType(Enum): @@ -63,47 +62,20 @@ class VariableType(Enum): VARIABLE_INFO = [ {"name": "ACh", "units": "millimolar", "component": "Rate_modulation_experiments", "type": VariableType.CONSTANT}, {"name": "Iso_1_uM", "units": "dimensionless", "component": "Rate_modulation_experiments", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "Ionic_values", "type": VariableType.ALGEBRAIC}, - {"name": "RTONF", "units": "millivolt", "component": "Membrane", "type": VariableType.COMPUTED_CONSTANT}, {"name": "Nao", "units": "millimolar", "component": "Ionic_values", "type": VariableType.CONSTANT}, - {"name": "Nai", "units": "millimolar", "component": "Nai_concentration", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "Ionic_values", "type": VariableType.COMPUTED_CONSTANT}, {"name": "Ko", "units": "millimolar", "component": "Ionic_values", "type": VariableType.CONSTANT}, {"name": "Ki", "units": "millimolar", "component": "Ionic_values", "type": VariableType.CONSTANT}, - {"name": "E_Ca", "units": "millivolt", "component": "Ionic_values", "type": VariableType.ALGEBRAIC}, {"name": "Cao", "units": "millimolar", "component": "Ionic_values", "type": VariableType.CONSTANT}, {"name": "Nai_clamp", "units": "dimensionless", "component": "Nai_concentration", "type": VariableType.CONSTANT}, - {"name": "i_Na", "units": "nanoA", "component": "i_Na", "type": VariableType.ALGEBRAIC}, - {"name": "i_NaCa", "units": "nanoA", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "i_NaK", "units": "nanoA", "component": "i_NaK", "type": VariableType.ALGEBRAIC}, - {"name": "i_siNa", "units": "nanoA", "component": "i_CaL", "type": VariableType.ALGEBRAIC}, - {"name": "i_fNa", "units": "nanoA", "component": "i_f", "type": VariableType.ALGEBRAIC}, {"name": "F", "units": "coulomb_per_mole", "component": "Membrane", "type": VariableType.CONSTANT}, - {"name": "V_i", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "V_sub", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "Iso_increase", "units": "dimensionless", "component": "i_NaK", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "V", "units": "millivolt", "component": "Membrane", "type": VariableType.ALGEBRAIC}, {"name": "Km_Nap", "units": "millimolar", "component": "i_NaK", "type": VariableType.CONSTANT}, {"name": "Km_Kp", "units": "millimolar", "component": "i_NaK", "type": VariableType.CONSTANT}, {"name": "i_NaK_max", "units": "nanoA", "component": "i_NaK", "type": VariableType.CONSTANT}, {"name": "blockade_NaCa", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "x2", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k21", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "x1", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k12", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, {"name": "K_NaCa", "units": "nanoA", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "x4", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "x3", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k41", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k23", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k34", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "k43", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k32", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k14", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, {"name": "K3ni", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, {"name": "Kci", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, {"name": "Qci", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "di", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, {"name": "K1ni", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, {"name": "K2ni", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, {"name": "Qn", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.CONSTANT}, @@ -111,152 +83,185 @@ class VariableType(Enum): {"name": "K3no", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, {"name": "Kco", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, {"name": "Qco", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "do", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, {"name": "K1no", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, {"name": "K2no", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "j_SRCarel", "units": "millimolar_per_second", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, {"name": "ks", "units": "per_second", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "diff", "units": "millimolar", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, - {"name": "kCaSR", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, {"name": "MaxSR", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, {"name": "MinSR", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, {"name": "EC50_SR", "units": "millimolar", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, {"name": "HSR", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "koSRCa", "units": "per_millimolar2_second", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, {"name": "koCa", "units": "per_millimolar2_second", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "kiSRCa", "units": "per_millimolar_second", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, {"name": "kiCa", "units": "per_millimolar_second", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, {"name": "kim", "units": "per_second", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, {"name": "kom", "units": "per_second", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "P_tot", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, - {"name": "b_up", "units": "dimensionless", "component": "Ca_intracellular_fluxes", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "P_up", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.COMPUTED_CONSTANT}, {"name": "P_up_basal", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.CONSTANT}, - {"name": "j_Ca_dif", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.ALGEBRAIC}, {"name": "tau_dif_Ca", "units": "second", "component": "Ca_intracellular_fluxes", "type": VariableType.CONSTANT}, - {"name": "j_up", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.ALGEBRAIC}, {"name": "K_up", "units": "millimolar", "component": "Ca_intracellular_fluxes", "type": VariableType.CONSTANT}, {"name": "slope_up", "units": "millimolar", "component": "Ca_intracellular_fluxes", "type": VariableType.CONSTANT}, - {"name": "j_tr", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.ALGEBRAIC}, {"name": "tau_tr", "units": "second", "component": "Ca_intracellular_fluxes", "type": VariableType.CONSTANT}, - {"name": "delta_fTC", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, {"name": "kf_TC", "units": "per_millimolar_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, {"name": "kb_TC", "units": "per_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "delta_fTMC", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, {"name": "kf_TMC", "units": "per_millimolar_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, {"name": "kb_TMC", "units": "per_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "delta_fTMM", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, {"name": "kf_TMM", "units": "per_millimolar_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, {"name": "Mgi", "units": "millimolar", "component": "Ca_buffering", "type": VariableType.CONSTANT}, {"name": "kb_TMM", "units": "per_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "delta_fCMi", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, {"name": "kf_CM", "units": "per_millimolar_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, {"name": "kb_CM", "units": "per_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "delta_fCMs", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, - {"name": "delta_fCQ", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, {"name": "kf_CQ", "units": "per_millimolar_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, {"name": "kb_CQ", "units": "per_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, {"name": "TC_tot", "units": "millimolar", "component": "Ca_buffering", "type": VariableType.CONSTANT}, {"name": "TMC_tot", "units": "millimolar", "component": "Ca_buffering", "type": VariableType.CONSTANT}, {"name": "CM_tot", "units": "millimolar", "component": "Ca_buffering", "type": VariableType.CONSTANT}, {"name": "CQ_tot", "units": "millimolar", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "V_nsr", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "V_jsr", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "i_siCa", "units": "nanoA", "component": "i_CaL", "type": VariableType.ALGEBRAIC}, - {"name": "i_CaT", "units": "nanoA", "component": "i_CaT", "type": VariableType.ALGEBRAIC}, - {"name": "V_cell", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, {"name": "L_cell", "units": "micrometre", "component": "Cell_parameters", "type": VariableType.CONSTANT}, {"name": "R_cell", "units": "micrometre", "component": "Cell_parameters", "type": VariableType.CONSTANT}, {"name": "L_sub", "units": "micrometre", "component": "Cell_parameters", "type": VariableType.CONSTANT}, {"name": "V_jsr_part", "units": "dimensionless", "component": "Cell_parameters", "type": VariableType.CONSTANT}, {"name": "V_i_part", "units": "dimensionless", "component": "Cell_parameters", "type": VariableType.CONSTANT}, {"name": "V_nsr_part", "units": "dimensionless", "component": "Cell_parameters", "type": VariableType.CONSTANT}, - {"name": "i_tot", "units": "nanoA", "component": "Membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_f", "units": "nanoA", "component": "i_f", "type": VariableType.ALGEBRAIC}, - {"name": "i_Kur", "units": "nanoA", "component": "i_Kur", "type": VariableType.ALGEBRAIC}, - {"name": "i_KACh", "units": "nanoA", "component": "i_KACh", "type": VariableType.ALGEBRAIC}, - {"name": "i_CaL", "units": "nanoA", "component": "i_CaL", "type": VariableType.ALGEBRAIC}, - {"name": "i_to", "units": "nanoA", "component": "i_to", "type": VariableType.ALGEBRAIC}, - {"name": "i_Ks", "units": "nanoA", "component": "i_Ks", "type": VariableType.ALGEBRAIC}, - {"name": "i_Kr", "units": "nanoA", "component": "i_Kr", "type": VariableType.ALGEBRAIC}, {"name": "C", "units": "microF", "component": "Membrane", "type": VariableType.CONSTANT}, {"name": "R", "units": "joule_per_kilomole_kelvin", "component": "Membrane", "type": VariableType.CONSTANT}, {"name": "T", "units": "kelvin", "component": "Membrane", "type": VariableType.CONSTANT}, - {"name": "V_clamp", "units": "millivolt", "component": "Voltage_clamp", "type": VariableType.ALGEBRAIC}, {"name": "clamp_mode", "units": "dimensionless", "component": "Membrane", "type": VariableType.CONSTANT}, {"name": "V_test", "units": "millivolt", "component": "Voltage_clamp", "type": VariableType.CONSTANT}, {"name": "t_holding", "units": "second", "component": "Voltage_clamp", "type": VariableType.CONSTANT}, {"name": "t_test", "units": "second", "component": "Voltage_clamp", "type": VariableType.CONSTANT}, {"name": "V_holding", "units": "millivolt", "component": "Voltage_clamp", "type": VariableType.CONSTANT}, - {"name": "G_f", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_f", "units": "microS", "component": "i_f", "type": VariableType.CONSTANT}, {"name": "Km_f", "units": "millimolar", "component": "i_f", "type": VariableType.CONSTANT}, - {"name": "G_f_K", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, {"name": "alpha", "units": "dimensionless", "component": "i_f", "type": VariableType.CONSTANT}, + {"name": "blockade", "units": "dimensionless", "component": "i_f", "type": VariableType.CONSTANT}, + {"name": "y_shift", "units": "millivolt", "component": "i_f_y_gate", "type": VariableType.CONSTANT}, + {"name": "g_Na", "units": "microS", "component": "i_Na", "type": VariableType.CONSTANT}, + {"name": "g_Na_L", "units": "microS", "component": "i_Na", "type": VariableType.CONSTANT}, + {"name": "delta_m", "units": "millivolt", "component": "i_Na_m_gate", "type": VariableType.CONSTANT}, + {"name": "g_Kur", "units": "microS", "component": "i_Kur", "type": VariableType.CONSTANT}, + {"name": "P_CaL", "units": "nanoA_per_millimolar", "component": "i_CaL", "type": VariableType.CONSTANT}, + {"name": "V_dL", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.CONSTANT}, + {"name": "k_dL", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.CONSTANT}, + {"name": "shift_fL", "units": "millivolt", "component": "i_CaL_fL_gate", "type": VariableType.CONSTANT}, + {"name": "k_fL", "units": "millivolt", "component": "i_CaL_fL_gate", "type": VariableType.CONSTANT}, + {"name": "Km_fCa", "units": "millimolar", "component": "i_CaL_fCa_gate", "type": VariableType.CONSTANT}, + {"name": "alpha_fCa", "units": "per_second", "component": "i_CaL_fCa_gate", "type": VariableType.CONSTANT}, + {"name": "P_CaT", "units": "nanoA_per_millimolar", "component": "i_CaT", "type": VariableType.CONSTANT}, + {"name": "offset_fT", "units": "second", "component": "i_CaT_fT_gate", "type": VariableType.CONSTANT}, + {"name": "g_to", "units": "microS", "component": "i_to", "type": VariableType.CONSTANT}, + {"name": "g_Kr", "units": "microS", "component": "i_Kr", "type": VariableType.CONSTANT}, + {"name": "g_Ks_", "units": "microS", "component": "i_Ks", "type": VariableType.CONSTANT}, + {"name": "ACh_on", "units": "dimensionless", "component": "i_KACh", "type": VariableType.CONSTANT}, + {"name": "g_KACh", "units": "microS", "component": "i_KACh", "type": VariableType.CONSTANT}, + {"name": "RTONF", "units": "millivolt", "component": "Membrane", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "Ionic_values", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "V_i", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "V_sub", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "Iso_increase", "units": "dimensionless", "component": "i_NaK", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "k34", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "b_up", "units": "dimensionless", "component": "Ca_intracellular_fluxes", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "P_up", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "V_nsr", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "V_jsr", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "V_cell", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "G_f", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "G_f_K", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, {"name": "G_f_Na", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_f_Na", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_f_K", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "blockade", "units": "dimensionless", "component": "i_f", "type": VariableType.CONSTANT}, - {"name": "i_fK", "units": "nanoA", "component": "i_f", "type": VariableType.ALGEBRAIC}, {"name": "ACh_shift", "units": "millivolt", "component": "i_f_y_gate", "type": VariableType.COMPUTED_CONSTANT}, {"name": "Iso_shift", "units": "millivolt", "component": "i_f_y_gate", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "Iso_increase", "units": "dimensionless", "component": "i_CaL", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "ACh_block", "units": "dimensionless", "component": "i_CaL", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "Iso_shift_dL", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "Iso_slope_dL", "units": "dimensionless", "component": "i_CaL_dL_gate", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_Ks", "units": "microS", "component": "i_Ks", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "Iso_shift", "units": "millivolt", "component": "i_Ks_n_gate", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "alpha_a", "units": "per_second", "component": "i_KACh_a_gate", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "Ionic_values", "type": VariableType.ALGEBRAIC}, + {"name": "Nai", "units": "millimolar", "component": "Nai_concentration", "type": VariableType.ALGEBRAIC}, + {"name": "E_Ca", "units": "millivolt", "component": "Ionic_values", "type": VariableType.ALGEBRAIC}, + {"name": "i_Na", "units": "nanoA", "component": "i_Na", "type": VariableType.ALGEBRAIC}, + {"name": "i_NaCa", "units": "nanoA", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "i_NaK", "units": "nanoA", "component": "i_NaK", "type": VariableType.ALGEBRAIC}, + {"name": "i_siNa", "units": "nanoA", "component": "i_CaL", "type": VariableType.ALGEBRAIC}, + {"name": "i_fNa", "units": "nanoA", "component": "i_f", "type": VariableType.ALGEBRAIC}, + {"name": "V", "units": "millivolt", "component": "Membrane", "type": VariableType.ALGEBRAIC}, + {"name": "x2", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "k21", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "x1", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "k12", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "x4", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "x3", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "k41", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "k23", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "k43", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "k32", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "k14", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "di", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "do", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, + {"name": "j_SRCarel", "units": "millimolar_per_second", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, + {"name": "diff", "units": "millimolar", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, + {"name": "kCaSR", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, + {"name": "koSRCa", "units": "per_millimolar2_second", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, + {"name": "kiSRCa", "units": "per_millimolar_second", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, + {"name": "P_tot", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, + {"name": "j_Ca_dif", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.ALGEBRAIC}, + {"name": "j_up", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.ALGEBRAIC}, + {"name": "j_tr", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.ALGEBRAIC}, + {"name": "delta_fTC", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, + {"name": "delta_fTMC", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, + {"name": "delta_fTMM", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, + {"name": "delta_fCMi", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, + {"name": "delta_fCMs", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, + {"name": "delta_fCQ", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, + {"name": "i_siCa", "units": "nanoA", "component": "i_CaL", "type": VariableType.ALGEBRAIC}, + {"name": "i_CaT", "units": "nanoA", "component": "i_CaT", "type": VariableType.ALGEBRAIC}, + {"name": "i_tot", "units": "nanoA", "component": "Membrane", "type": VariableType.ALGEBRAIC}, + {"name": "i_f", "units": "nanoA", "component": "i_f", "type": VariableType.ALGEBRAIC}, + {"name": "i_Kur", "units": "nanoA", "component": "i_Kur", "type": VariableType.ALGEBRAIC}, + {"name": "i_KACh", "units": "nanoA", "component": "i_KACh", "type": VariableType.ALGEBRAIC}, + {"name": "i_CaL", "units": "nanoA", "component": "i_CaL", "type": VariableType.ALGEBRAIC}, + {"name": "i_to", "units": "nanoA", "component": "i_to", "type": VariableType.ALGEBRAIC}, + {"name": "i_Ks", "units": "nanoA", "component": "i_Ks", "type": VariableType.ALGEBRAIC}, + {"name": "i_Kr", "units": "nanoA", "component": "i_Kr", "type": VariableType.ALGEBRAIC}, + {"name": "V_clamp", "units": "millivolt", "component": "Voltage_clamp", "type": VariableType.ALGEBRAIC}, + {"name": "i_fK", "units": "nanoA", "component": "i_f", "type": VariableType.ALGEBRAIC}, {"name": "tau_y", "units": "second", "component": "i_f_y_gate", "type": VariableType.ALGEBRAIC}, {"name": "y_infinity", "units": "dimensionless", "component": "i_f_y_gate", "type": VariableType.ALGEBRAIC}, - {"name": "y_shift", "units": "millivolt", "component": "i_f_y_gate", "type": VariableType.CONSTANT}, {"name": "E_mh", "units": "millivolt", "component": "i_Na", "type": VariableType.ALGEBRAIC}, {"name": "i_Na_", "units": "nanoA", "component": "i_Na", "type": VariableType.ALGEBRAIC}, - {"name": "g_Na", "units": "microS", "component": "i_Na", "type": VariableType.CONSTANT}, {"name": "i_Na_L", "units": "nanoA", "component": "i_Na", "type": VariableType.ALGEBRAIC}, - {"name": "g_Na_L", "units": "microS", "component": "i_Na", "type": VariableType.CONSTANT}, {"name": "m_infinity", "units": "dimensionless", "component": "i_Na_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "E0_m", "units": "millivolt", "component": "i_Na_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_m", "units": "per_second", "component": "i_Na_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "delta_m", "units": "millivolt", "component": "i_Na_m_gate", "type": VariableType.CONSTANT}, {"name": "beta_m", "units": "per_second", "component": "i_Na_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "tau_m", "units": "second", "component": "i_Na_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "h_infinity", "units": "dimensionless", "component": "i_Na_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_second", "component": "i_Na_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_second", "component": "i_Na_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "tau_h", "units": "second", "component": "i_Na_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "g_Kur", "units": "microS", "component": "i_Kur", "type": VariableType.CONSTANT}, {"name": "r_Kur_infinity", "units": "dimensionless", "component": "i_Kur_rKur_gate", "type": VariableType.ALGEBRAIC}, {"name": "tau_r_Kur", "units": "second", "component": "i_Kur_rKur_gate", "type": VariableType.ALGEBRAIC}, {"name": "s_Kur_infinity", "units": "dimensionless", "component": "i_Kur_sKur_gate", "type": VariableType.ALGEBRAIC}, {"name": "tau_s_Kur", "units": "second", "component": "i_Kur_sKur_gate", "type": VariableType.ALGEBRAIC}, - {"name": "Iso_increase", "units": "dimensionless", "component": "i_CaL", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "P_CaL", "units": "nanoA_per_millimolar", "component": "i_CaL", "type": VariableType.CONSTANT}, {"name": "i_siK", "units": "nanoA", "component": "i_CaL", "type": VariableType.ALGEBRAIC}, - {"name": "ACh_block", "units": "dimensionless", "component": "i_CaL", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "Iso_shift_dL", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "Iso_slope_dL", "units": "dimensionless", "component": "i_CaL_dL_gate", "type": VariableType.COMPUTED_CONSTANT}, {"name": "dL_infinity", "units": "dimensionless", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, - {"name": "V_dL", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.CONSTANT}, - {"name": "k_dL", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.CONSTANT}, {"name": "tau_dL", "units": "second", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_dL", "units": "per_second", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_dL", "units": "per_second", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, {"name": "adVm", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, {"name": "bdVm", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, {"name": "fL_infinity", "units": "dimensionless", "component": "i_CaL_fL_gate", "type": VariableType.ALGEBRAIC}, - {"name": "shift_fL", "units": "millivolt", "component": "i_CaL_fL_gate", "type": VariableType.CONSTANT}, - {"name": "k_fL", "units": "millivolt", "component": "i_CaL_fL_gate", "type": VariableType.CONSTANT}, {"name": "tau_fL", "units": "second", "component": "i_CaL_fL_gate", "type": VariableType.ALGEBRAIC}, {"name": "fCa_infinity", "units": "dimensionless", "component": "i_CaL_fCa_gate", "type": VariableType.ALGEBRAIC}, - {"name": "Km_fCa", "units": "millimolar", "component": "i_CaL_fCa_gate", "type": VariableType.CONSTANT}, {"name": "tau_fCa", "units": "second", "component": "i_CaL_fCa_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_fCa", "units": "per_second", "component": "i_CaL_fCa_gate", "type": VariableType.CONSTANT}, - {"name": "P_CaT", "units": "nanoA_per_millimolar", "component": "i_CaT", "type": VariableType.CONSTANT}, {"name": "dT_infinity", "units": "dimensionless", "component": "i_CaT_dT_gate", "type": VariableType.ALGEBRAIC}, {"name": "tau_dT", "units": "second", "component": "i_CaT_dT_gate", "type": VariableType.ALGEBRAIC}, {"name": "fT_infinity", "units": "dimensionless", "component": "i_CaT_fT_gate", "type": VariableType.ALGEBRAIC}, {"name": "tau_fT", "units": "second", "component": "i_CaT_fT_gate", "type": VariableType.ALGEBRAIC}, - {"name": "offset_fT", "units": "second", "component": "i_CaT_fT_gate", "type": VariableType.CONSTANT}, - {"name": "g_to", "units": "microS", "component": "i_to", "type": VariableType.CONSTANT}, {"name": "q_infinity", "units": "dimensionless", "component": "i_to_q_gate", "type": VariableType.ALGEBRAIC}, {"name": "tau_q", "units": "second", "component": "i_to_q_gate", "type": VariableType.ALGEBRAIC}, {"name": "r_infinity", "units": "dimensionless", "component": "i_to_r_gate", "type": VariableType.ALGEBRAIC}, {"name": "tau_r", "units": "second", "component": "i_to_r_gate", "type": VariableType.ALGEBRAIC}, - {"name": "g_Kr", "units": "microS", "component": "i_Kr", "type": VariableType.CONSTANT}, {"name": "alfapaF", "units": "per_second", "component": "i_Kr_pa_gate", "type": VariableType.ALGEBRAIC}, {"name": "betapaF", "units": "per_second", "component": "i_Kr_pa_gate", "type": VariableType.ALGEBRAIC}, {"name": "pa_infinity", "units": "dimensionless", "component": "i_Kr_pa_gate", "type": VariableType.ALGEBRAIC}, @@ -264,17 +269,11 @@ class VariableType(Enum): {"name": "tau_paF", "units": "second", "component": "i_Kr_pa_gate", "type": VariableType.ALGEBRAIC}, {"name": "tau_pi", "units": "second", "component": "i_Kr_pi_gate", "type": VariableType.ALGEBRAIC}, {"name": "pi_infinity", "units": "dimensionless", "component": "i_Kr_pi_gate", "type": VariableType.ALGEBRAIC}, - {"name": "g_Ks", "units": "microS", "component": "i_Ks", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_Ks_", "units": "microS", "component": "i_Ks", "type": VariableType.CONSTANT}, {"name": "E_Ks", "units": "millivolt", "component": "i_Ks", "type": VariableType.ALGEBRAIC}, - {"name": "Iso_shift", "units": "millivolt", "component": "i_Ks_n_gate", "type": VariableType.COMPUTED_CONSTANT}, {"name": "n_infinity", "units": "dimensionless", "component": "i_Ks_n_gate", "type": VariableType.ALGEBRAIC}, {"name": "tau_n", "units": "second", "component": "i_Ks_n_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_n", "units": "per_second", "component": "i_Ks_n_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_n", "units": "per_second", "component": "i_Ks_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "ACh_on", "units": "dimensionless", "component": "i_KACh", "type": VariableType.CONSTANT}, - {"name": "g_KACh", "units": "microS", "component": "i_KACh", "type": VariableType.CONSTANT}, - {"name": "alpha_a", "units": "per_second", "component": "i_KACh_a_gate", "type": VariableType.COMPUTED_CONSTANT}, {"name": "beta_a", "units": "per_second", "component": "i_KACh_a_gate", "type": VariableType.ALGEBRAIC}, {"name": "a_infinity", "units": "dimensionless", "component": "i_KACh_a_gate", "type": VariableType.ALGEBRAIC}, {"name": "tau_a", "units": "second", "component": "i_KACh_a_gate", "type": VariableType.ALGEBRAIC} diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 19a61164c..798a745ca 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 15; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 185; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 110; +const size_t COMPUTED_CONSTANT_COUNT = 23; +const size_t ALGEBRAIC_COUNT = 52; const VariableInfo VOI_INFO = {"time", "second", "environment", VARIABLE_OF_INTEGRATION}; @@ -35,56 +34,32 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"FCell", "dimensionless", "membrane", COMPUTED_CONSTANT}, {"dCell", "dimensionless", "membrane", CONSTANT}, {"Version", "dimensionless", "membrane", CONSTANT}, {"FCellConstant", "dimensionless", "membrane", CONSTANT}, - {"Cm", "microF", "membrane", COMPUTED_CONSTANT}, {"CmCentre", "microF", "membrane", CONSTANT}, {"CmPeriphery", "microF", "membrane", CONSTANT}, - {"i_Na", "nanoA", "sodium_current", ALGEBRAIC}, - {"i_Ca_p", "nanoA", "persistent_calcium_current", COMPUTED_CONSTANT}, - {"i_p", "nanoA", "sodium_potassium_pump", ALGEBRAIC}, - {"i_NaCa", "nanoA", "sodium_calcium_exchanger", ALGEBRAIC}, - {"i_b_K", "nanoA", "potassium_background_current", ALGEBRAIC}, - {"i_b_Ca", "nanoA", "calcium_background_current", ALGEBRAIC}, - {"i_b_Na", "nanoA", "sodium_background_current", ALGEBRAIC}, - {"i_f_K", "nanoA", "hyperpolarisation_activated_current", ALGEBRAIC}, - {"i_f_Na", "nanoA", "hyperpolarisation_activated_current", ALGEBRAIC}, - {"i_K_s", "nanoA", "slow_delayed_rectifying_potassium_current", ALGEBRAIC}, - {"i_K_r", "nanoA", "rapid_delayed_rectifying_potassium_current", ALGEBRAIC}, - {"i_sus", "nanoA", "four_AP_sensitive_currents", ALGEBRAIC}, - {"i_to", "nanoA", "four_AP_sensitive_currents", ALGEBRAIC}, - {"i_Ca_T", "nanoA", "T_type_Ca_channel", ALGEBRAIC}, - {"i_Ca_L", "nanoA", "L_type_Ca_channel", ALGEBRAIC}, {"R", "millijoule_per_mole_kelvin", "membrane", CONSTANT}, {"T", "kelvin", "membrane", CONSTANT}, {"F", "coulomb_per_mole", "membrane", CONSTANT}, - {"g_b_Na", "microS", "sodium_background_current", COMPUTED_CONSTANT}, {"g_b_Na_Centre_Published", "microS", "sodium_background_current", CONSTANT}, {"g_b_Na_Periphery_Published", "microS", "sodium_background_current", CONSTANT}, {"g_b_Na_Centre_1DCapable", "microS", "sodium_background_current", CONSTANT}, {"g_b_Na_Periphery_1DCapable", "microS", "sodium_background_current", CONSTANT}, {"g_b_Na_Centre_0DCapable", "microS", "sodium_background_current", CONSTANT}, {"g_b_Na_Periphery_0DCapable", "microS", "sodium_background_current", CONSTANT}, - {"E_Na", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, - {"g_b_K", "microS", "potassium_background_current", COMPUTED_CONSTANT}, {"g_b_K_Centre_Published", "microS", "potassium_background_current", CONSTANT}, {"g_b_K_Periphery_Published", "microS", "potassium_background_current", CONSTANT}, {"g_b_K_Centre_1DCapable", "microS", "potassium_background_current", CONSTANT}, {"g_b_K_Periphery_1DCapable", "microS", "potassium_background_current", CONSTANT}, {"g_b_K_Centre_0DCapable", "microS", "potassium_background_current", CONSTANT}, {"g_b_K_Periphery_0DCapable", "microS", "potassium_background_current", CONSTANT}, - {"E_K", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, - {"g_b_Ca", "microS", "calcium_background_current", COMPUTED_CONSTANT}, {"g_b_Ca_Centre_Published", "microS", "calcium_background_current", CONSTANT}, {"g_b_Ca_Periphery_Published", "microS", "calcium_background_current", CONSTANT}, {"g_b_Ca_Centre_1DCapable", "microS", "calcium_background_current", CONSTANT}, {"g_b_Ca_Periphery_1DCapable", "microS", "calcium_background_current", CONSTANT}, {"g_b_Ca_Centre_0DCapable", "microS", "calcium_background_current", CONSTANT}, {"g_b_Ca_Periphery_0DCapable", "microS", "calcium_background_current", CONSTANT}, - {"E_Ca", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, - {"k_NaCa", "nanoA", "sodium_calcium_exchanger", COMPUTED_CONSTANT}, {"k_NaCa_Centre_Published", "nanoA", "sodium_calcium_exchanger", CONSTANT}, {"k_NaCa_Periphery_Published", "nanoA", "sodium_calcium_exchanger", CONSTANT}, {"k_NaCa_Centre_1DCapable", "nanoA", "sodium_calcium_exchanger", CONSTANT}, @@ -97,7 +72,6 @@ const VariableInfo VARIABLE_INFO[] = { {"Na_o", "millimolar", "ionic_concentrations", CONSTANT}, {"Ca_i", "millimolar", "ionic_concentrations", CONSTANT}, {"d_NaCa", "dimensionless", "sodium_calcium_exchanger", CONSTANT}, - {"i_p_max", "nanoA", "sodium_potassium_pump", COMPUTED_CONSTANT}, {"i_p_max_Centre_Published", "nanoA", "sodium_potassium_pump", CONSTANT}, {"i_p_max_Periphery_Published", "nanoA", "sodium_potassium_pump", CONSTANT}, {"i_p_max_Centre_1DCapable", "nanoA", "sodium_potassium_pump", CONSTANT}, @@ -107,7 +81,6 @@ const VariableInfo VARIABLE_INFO[] = { {"K_o", "millimolar", "ionic_concentrations", CONSTANT}, {"K_m_K", "millimolar", "sodium_potassium_pump", CONSTANT}, {"K_m_Na", "millimolar", "sodium_potassium_pump", CONSTANT}, - {"i_Ca_p_max", "nanoA", "persistent_calcium_current", COMPUTED_CONSTANT}, {"i_Ca_p_max_Centre_Published", "nanoA", "persistent_calcium_current", CONSTANT}, {"i_Ca_p_max_Periphery_Published", "nanoA", "persistent_calcium_current", CONSTANT}, {"i_Ca_p_max_Centre_1DCapable", "nanoA", "persistent_calcium_current", CONSTANT}, @@ -115,23 +88,12 @@ const VariableInfo VARIABLE_INFO[] = { {"i_Ca_p_max_Centre_0DCapable", "nanoA", "persistent_calcium_current", CONSTANT}, {"i_Ca_p_max_Periphery_0DCapable", "nanoA", "persistent_calcium_current", CONSTANT}, {"K_i", "millimolar", "ionic_concentrations", CONSTANT}, - {"E_K_s", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, - {"g_Na", "microlitre_per_second", "sodium_current", COMPUTED_CONSTANT}, {"g_Na_Centre_Published", "microlitre_per_second", "sodium_current", CONSTANT}, {"g_Na_Periphery_Published", "microlitre_per_second", "sodium_current", CONSTANT}, {"g_Na_Centre_1DCapable", "microlitre_per_second", "sodium_current", CONSTANT}, {"g_Na_Periphery_1DCapable", "microlitre_per_second", "sodium_current", CONSTANT}, {"g_Na_Centre_0DCapable", "microlitre_per_second", "sodium_current", CONSTANT}, {"g_Na_Periphery_0DCapable", "microlitre_per_second", "sodium_current", CONSTANT}, - {"h", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, - {"m_infinity", "dimensionless", "sodium_current_m_gate", ALGEBRAIC}, - {"tau_m", "second", "sodium_current_m_gate", ALGEBRAIC}, - {"F_Na", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, - {"h1_infinity", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, - {"tau_h1", "second", "sodium_current_h_gate", ALGEBRAIC}, - {"h2_infinity", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, - {"tau_h2", "second", "sodium_current_h_gate", ALGEBRAIC}, - {"g_Ca_L", "microS", "L_type_Ca_channel", COMPUTED_CONSTANT}, {"g_Ca_L_Centre_Published", "microS", "L_type_Ca_channel", CONSTANT}, {"g_Ca_L_Periphery_Published", "microS", "L_type_Ca_channel", CONSTANT}, {"g_Ca_L_Centre_1DCapable", "microS", "L_type_Ca_channel", CONSTANT}, @@ -139,15 +101,6 @@ const VariableInfo VARIABLE_INFO[] = { {"g_Ca_L_Centre_0DCapable", "microS", "L_type_Ca_channel", CONSTANT}, {"g_Ca_L_Periphery_0DCapable", "microS", "L_type_Ca_channel", CONSTANT}, {"E_Ca_L", "millivolt", "L_type_Ca_channel", CONSTANT}, - {"d_L_infinity", "dimensionless", "L_type_Ca_channel_d_gate", ALGEBRAIC}, - {"tau_d_L", "second", "L_type_Ca_channel_d_gate", ALGEBRAIC}, - {"alpha_d_L", "per_second", "L_type_Ca_channel_d_gate", ALGEBRAIC}, - {"beta_d_L", "per_second", "L_type_Ca_channel_d_gate", ALGEBRAIC}, - {"f_L_infinity", "dimensionless", "L_type_Ca_channel_f_gate", ALGEBRAIC}, - {"tau_f_L", "second", "L_type_Ca_channel_f_gate", ALGEBRAIC}, - {"alpha_f_L", "per_second", "L_type_Ca_channel_f_gate", ALGEBRAIC}, - {"beta_f_L", "per_second", "L_type_Ca_channel_f_gate", ALGEBRAIC}, - {"g_Ca_T", "microS", "T_type_Ca_channel", COMPUTED_CONSTANT}, {"g_Ca_T_Centre_Published", "microS", "T_type_Ca_channel", CONSTANT}, {"g_Ca_T_Periphery_Published", "microS", "T_type_Ca_channel", CONSTANT}, {"g_Ca_T_Centre_1DCapable", "microS", "T_type_Ca_channel", CONSTANT}, @@ -155,69 +108,115 @@ const VariableInfo VARIABLE_INFO[] = { {"g_Ca_T_Centre_0DCapable", "microS", "T_type_Ca_channel", CONSTANT}, {"g_Ca_T_Periphery_0DCapable", "microS", "T_type_Ca_channel", CONSTANT}, {"E_Ca_T", "millivolt", "T_type_Ca_channel", CONSTANT}, - {"d_T_infinity", "dimensionless", "T_type_Ca_channel_d_gate", ALGEBRAIC}, - {"tau_d_T", "second", "T_type_Ca_channel_d_gate", ALGEBRAIC}, - {"alpha_d_T", "per_second", "T_type_Ca_channel_d_gate", ALGEBRAIC}, - {"beta_d_T", "per_second", "T_type_Ca_channel_d_gate", ALGEBRAIC}, - {"f_T_infinity", "dimensionless", "T_type_Ca_channel_f_gate", ALGEBRAIC}, - {"tau_f_T", "second", "T_type_Ca_channel_f_gate", ALGEBRAIC}, - {"alpha_f_T", "per_second", "T_type_Ca_channel_f_gate", ALGEBRAIC}, - {"beta_f_T", "per_second", "T_type_Ca_channel_f_gate", ALGEBRAIC}, - {"g_to", "microS", "four_AP_sensitive_currents", COMPUTED_CONSTANT}, {"g_to_Centre_Published", "microS", "four_AP_sensitive_currents", CONSTANT}, {"g_to_Periphery_Published", "microS", "four_AP_sensitive_currents", CONSTANT}, {"g_to_Centre_1DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, {"g_to_Periphery_1DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, {"g_to_Centre_0DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, {"g_to_Periphery_0DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_sus", "microS", "four_AP_sensitive_currents", COMPUTED_CONSTANT}, {"g_sus_Centre_Published", "microS", "four_AP_sensitive_currents", CONSTANT}, {"g_sus_Periphery_Published", "microS", "four_AP_sensitive_currents", CONSTANT}, {"g_sus_Centre_1DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, {"g_sus_Periphery_1DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, {"g_sus_Centre_0DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, {"g_sus_Periphery_0DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"q_infinity", "dimensionless", "four_AP_sensitive_currents_q_gate", ALGEBRAIC}, - {"tau_q", "second", "four_AP_sensitive_currents_q_gate", ALGEBRAIC}, - {"r_infinity", "dimensionless", "four_AP_sensitive_currents_r_gate", ALGEBRAIC}, - {"tau_r", "second", "four_AP_sensitive_currents_r_gate", ALGEBRAIC}, - {"g_K_r", "microS", "rapid_delayed_rectifying_potassium_current", COMPUTED_CONSTANT}, {"g_K_r_Centre_Published", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, {"g_K_r_Periphery_Published", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, {"g_K_r_Centre_1DCapable", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, {"g_K_r_Periphery_1DCapable", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, {"g_K_r_Centre_0DCapable", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, {"g_K_r_Periphery_0DCapable", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, - {"P_a", "dimensionless", "rapid_delayed_rectifying_potassium_current", ALGEBRAIC}, - {"P_af_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_af_gate", ALGEBRAIC}, - {"tau_P_af", "second", "rapid_delayed_rectifying_potassium_current_P_af_gate", ALGEBRAIC}, - {"P_as_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_as_gate", ALGEBRAIC}, - {"tau_P_as", "second", "rapid_delayed_rectifying_potassium_current_P_as_gate", ALGEBRAIC}, - {"tau_P_i", "second", "rapid_delayed_rectifying_potassium_current_P_i_gate", COMPUTED_CONSTANT}, - {"P_i_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_i_gate", ALGEBRAIC}, - {"g_K_s", "microS", "slow_delayed_rectifying_potassium_current", COMPUTED_CONSTANT}, {"g_K_s_Centre_Published", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, {"g_K_s_Periphery_Published", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, {"g_K_s_Centre_1DCapable", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, {"g_K_s_Periphery_1DCapable", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, {"g_K_s_Centre_0DCapable", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, {"g_K_s_Periphery_0DCapable", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, - {"alpha_xs", "per_second", "slow_delayed_rectifying_potassium_current_xs_gate", ALGEBRAIC}, - {"beta_xs", "per_second", "slow_delayed_rectifying_potassium_current_xs_gate", ALGEBRAIC}, - {"g_f_Na", "microS", "hyperpolarisation_activated_current", COMPUTED_CONSTANT}, {"g_f_Na_Centre_Published", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_Na_Periphery_Published", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_Na_Centre_1DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_Na_Periphery_1DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_Na_Centre_0DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_Na_Periphery_0DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_K", "microS", "hyperpolarisation_activated_current", COMPUTED_CONSTANT}, {"g_f_K_Centre_Published", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_K_Periphery_Published", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_K_Centre_1DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_K_Periphery_1DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_K_Centre_0DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_K_Periphery_0DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, + {"FCell", "dimensionless", "membrane", COMPUTED_CONSTANT}, + {"Cm", "microF", "membrane", COMPUTED_CONSTANT}, + {"i_Ca_p", "nanoA", "persistent_calcium_current", COMPUTED_CONSTANT}, + {"g_b_Na", "microS", "sodium_background_current", COMPUTED_CONSTANT}, + {"E_Na", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, + {"g_b_K", "microS", "potassium_background_current", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, + {"g_b_Ca", "microS", "calcium_background_current", COMPUTED_CONSTANT}, + {"E_Ca", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, + {"k_NaCa", "nanoA", "sodium_calcium_exchanger", COMPUTED_CONSTANT}, + {"i_p_max", "nanoA", "sodium_potassium_pump", COMPUTED_CONSTANT}, + {"i_Ca_p_max", "nanoA", "persistent_calcium_current", COMPUTED_CONSTANT}, + {"E_K_s", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, + {"g_Na", "microlitre_per_second", "sodium_current", COMPUTED_CONSTANT}, + {"g_Ca_L", "microS", "L_type_Ca_channel", COMPUTED_CONSTANT}, + {"g_Ca_T", "microS", "T_type_Ca_channel", COMPUTED_CONSTANT}, + {"g_to", "microS", "four_AP_sensitive_currents", COMPUTED_CONSTANT}, + {"g_sus", "microS", "four_AP_sensitive_currents", COMPUTED_CONSTANT}, + {"g_K_r", "microS", "rapid_delayed_rectifying_potassium_current", COMPUTED_CONSTANT}, + {"tau_P_i", "second", "rapid_delayed_rectifying_potassium_current_P_i_gate", COMPUTED_CONSTANT}, + {"g_K_s", "microS", "slow_delayed_rectifying_potassium_current", COMPUTED_CONSTANT}, + {"g_f_Na", "microS", "hyperpolarisation_activated_current", COMPUTED_CONSTANT}, + {"g_f_K", "microS", "hyperpolarisation_activated_current", COMPUTED_CONSTANT}, + {"i_Na", "nanoA", "sodium_current", ALGEBRAIC}, + {"i_p", "nanoA", "sodium_potassium_pump", ALGEBRAIC}, + {"i_NaCa", "nanoA", "sodium_calcium_exchanger", ALGEBRAIC}, + {"i_b_K", "nanoA", "potassium_background_current", ALGEBRAIC}, + {"i_b_Ca", "nanoA", "calcium_background_current", ALGEBRAIC}, + {"i_b_Na", "nanoA", "sodium_background_current", ALGEBRAIC}, + {"i_f_K", "nanoA", "hyperpolarisation_activated_current", ALGEBRAIC}, + {"i_f_Na", "nanoA", "hyperpolarisation_activated_current", ALGEBRAIC}, + {"i_K_s", "nanoA", "slow_delayed_rectifying_potassium_current", ALGEBRAIC}, + {"i_K_r", "nanoA", "rapid_delayed_rectifying_potassium_current", ALGEBRAIC}, + {"i_sus", "nanoA", "four_AP_sensitive_currents", ALGEBRAIC}, + {"i_to", "nanoA", "four_AP_sensitive_currents", ALGEBRAIC}, + {"i_Ca_T", "nanoA", "T_type_Ca_channel", ALGEBRAIC}, + {"i_Ca_L", "nanoA", "L_type_Ca_channel", ALGEBRAIC}, + {"h", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, + {"m_infinity", "dimensionless", "sodium_current_m_gate", ALGEBRAIC}, + {"tau_m", "second", "sodium_current_m_gate", ALGEBRAIC}, + {"F_Na", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, + {"h1_infinity", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, + {"tau_h1", "second", "sodium_current_h_gate", ALGEBRAIC}, + {"h2_infinity", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, + {"tau_h2", "second", "sodium_current_h_gate", ALGEBRAIC}, + {"d_L_infinity", "dimensionless", "L_type_Ca_channel_d_gate", ALGEBRAIC}, + {"tau_d_L", "second", "L_type_Ca_channel_d_gate", ALGEBRAIC}, + {"alpha_d_L", "per_second", "L_type_Ca_channel_d_gate", ALGEBRAIC}, + {"beta_d_L", "per_second", "L_type_Ca_channel_d_gate", ALGEBRAIC}, + {"f_L_infinity", "dimensionless", "L_type_Ca_channel_f_gate", ALGEBRAIC}, + {"tau_f_L", "second", "L_type_Ca_channel_f_gate", ALGEBRAIC}, + {"alpha_f_L", "per_second", "L_type_Ca_channel_f_gate", ALGEBRAIC}, + {"beta_f_L", "per_second", "L_type_Ca_channel_f_gate", ALGEBRAIC}, + {"d_T_infinity", "dimensionless", "T_type_Ca_channel_d_gate", ALGEBRAIC}, + {"tau_d_T", "second", "T_type_Ca_channel_d_gate", ALGEBRAIC}, + {"alpha_d_T", "per_second", "T_type_Ca_channel_d_gate", ALGEBRAIC}, + {"beta_d_T", "per_second", "T_type_Ca_channel_d_gate", ALGEBRAIC}, + {"f_T_infinity", "dimensionless", "T_type_Ca_channel_f_gate", ALGEBRAIC}, + {"tau_f_T", "second", "T_type_Ca_channel_f_gate", ALGEBRAIC}, + {"alpha_f_T", "per_second", "T_type_Ca_channel_f_gate", ALGEBRAIC}, + {"beta_f_T", "per_second", "T_type_Ca_channel_f_gate", ALGEBRAIC}, + {"q_infinity", "dimensionless", "four_AP_sensitive_currents_q_gate", ALGEBRAIC}, + {"tau_q", "second", "four_AP_sensitive_currents_q_gate", ALGEBRAIC}, + {"r_infinity", "dimensionless", "four_AP_sensitive_currents_r_gate", ALGEBRAIC}, + {"tau_r", "second", "four_AP_sensitive_currents_r_gate", ALGEBRAIC}, + {"P_a", "dimensionless", "rapid_delayed_rectifying_potassium_current", ALGEBRAIC}, + {"P_af_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_af_gate", ALGEBRAIC}, + {"tau_P_af", "second", "rapid_delayed_rectifying_potassium_current_P_af_gate", ALGEBRAIC}, + {"P_as_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_as_gate", ALGEBRAIC}, + {"tau_P_as", "second", "rapid_delayed_rectifying_potassium_current_P_as_gate", ALGEBRAIC}, + {"P_i_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_i_gate", ALGEBRAIC}, + {"alpha_xs", "per_second", "slow_delayed_rectifying_potassium_current_xs_gate", ALGEBRAIC}, + {"beta_xs", "per_second", "slow_delayed_rectifying_potassium_current_xs_gate", ALGEBRAIC}, {"alpha_y", "per_second", "hyperpolarisation_activated_current_y_gate", ALGEBRAIC}, {"beta_y", "per_second", "hyperpolarisation_activated_current_y_gate", ALGEBRAIC} }; diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 7ce78ee1d..2715ae2d9 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index c62e1982c..4c0443449 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 15 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 185 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 110 +COMPUTED_CONSTANT_COUNT = 23 +ALGEBRAIC_COUNT = 52 class VariableType(Enum): @@ -43,56 +42,32 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "FCell", "units": "dimensionless", "component": "membrane", "type": VariableType.COMPUTED_CONSTANT}, {"name": "dCell", "units": "dimensionless", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "Version", "units": "dimensionless", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "FCellConstant", "units": "dimensionless", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "Cm", "units": "microF", "component": "membrane", "type": VariableType.COMPUTED_CONSTANT}, {"name": "CmCentre", "units": "microF", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "CmPeriphery", "units": "microF", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "i_Na", "units": "nanoA", "component": "sodium_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_Ca_p", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "i_p", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.ALGEBRAIC}, - {"name": "i_NaCa", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.ALGEBRAIC}, - {"name": "i_b_K", "units": "nanoA", "component": "potassium_background_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_b_Ca", "units": "nanoA", "component": "calcium_background_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_b_Na", "units": "nanoA", "component": "sodium_background_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_f_K", "units": "nanoA", "component": "hyperpolarisation_activated_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_f_Na", "units": "nanoA", "component": "hyperpolarisation_activated_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K_s", "units": "nanoA", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K_r", "units": "nanoA", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_sus", "units": "nanoA", "component": "four_AP_sensitive_currents", "type": VariableType.ALGEBRAIC}, - {"name": "i_to", "units": "nanoA", "component": "four_AP_sensitive_currents", "type": VariableType.ALGEBRAIC}, - {"name": "i_Ca_T", "units": "nanoA", "component": "T_type_Ca_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Ca_L", "units": "nanoA", "component": "L_type_Ca_channel", "type": VariableType.ALGEBRAIC}, {"name": "R", "units": "millijoule_per_mole_kelvin", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "T", "units": "kelvin", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "F", "units": "coulomb_per_mole", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_b_Na", "units": "microS", "component": "sodium_background_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_b_Na_Centre_Published", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_Na_Periphery_Published", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_Na_Centre_1DCapable", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_Na_Periphery_1DCapable", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_Na_Centre_0DCapable", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_Na_Periphery_0DCapable", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_b_K", "units": "microS", "component": "potassium_background_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_b_K_Centre_Published", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_K_Periphery_Published", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_K_Centre_1DCapable", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_K_Periphery_1DCapable", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_K_Centre_0DCapable", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_K_Periphery_0DCapable", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_b_Ca", "units": "microS", "component": "calcium_background_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_b_Ca_Centre_Published", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_Ca_Periphery_Published", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_Ca_Centre_1DCapable", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_Ca_Periphery_1DCapable", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_Ca_Centre_0DCapable", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, {"name": "g_b_Ca_Periphery_0DCapable", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, - {"name": "E_Ca", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "k_NaCa", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.COMPUTED_CONSTANT}, {"name": "k_NaCa_Centre_Published", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, {"name": "k_NaCa_Periphery_Published", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, {"name": "k_NaCa_Centre_1DCapable", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, @@ -105,7 +80,6 @@ class VariableType(Enum): {"name": "Na_o", "units": "millimolar", "component": "ionic_concentrations", "type": VariableType.CONSTANT}, {"name": "Ca_i", "units": "millimolar", "component": "ionic_concentrations", "type": VariableType.CONSTANT}, {"name": "d_NaCa", "units": "dimensionless", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, - {"name": "i_p_max", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.COMPUTED_CONSTANT}, {"name": "i_p_max_Centre_Published", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, {"name": "i_p_max_Periphery_Published", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, {"name": "i_p_max_Centre_1DCapable", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, @@ -115,7 +89,6 @@ class VariableType(Enum): {"name": "K_o", "units": "millimolar", "component": "ionic_concentrations", "type": VariableType.CONSTANT}, {"name": "K_m_K", "units": "millimolar", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, {"name": "K_m_Na", "units": "millimolar", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, - {"name": "i_Ca_p_max", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "i_Ca_p_max_Centre_Published", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.CONSTANT}, {"name": "i_Ca_p_max_Periphery_Published", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.CONSTANT}, {"name": "i_Ca_p_max_Centre_1DCapable", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.CONSTANT}, @@ -123,23 +96,12 @@ class VariableType(Enum): {"name": "i_Ca_p_max_Centre_0DCapable", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.CONSTANT}, {"name": "i_Ca_p_max_Periphery_0DCapable", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.CONSTANT}, {"name": "K_i", "units": "millimolar", "component": "ionic_concentrations", "type": VariableType.CONSTANT}, - {"name": "E_K_s", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_Na", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Na_Centre_Published", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, {"name": "g_Na_Periphery_Published", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, {"name": "g_Na_Centre_1DCapable", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, {"name": "g_Na_Periphery_1DCapable", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, {"name": "g_Na_Centre_0DCapable", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, {"name": "g_Na_Periphery_0DCapable", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, - {"name": "h", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "m_infinity", "units": "dimensionless", "component": "sodium_current_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_m", "units": "second", "component": "sodium_current_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "F_Na", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "h1_infinity", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_h1", "units": "second", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "h2_infinity", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_h2", "units": "second", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "g_Ca_L", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Ca_L_Centre_Published", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, {"name": "g_Ca_L_Periphery_Published", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, {"name": "g_Ca_L_Centre_1DCapable", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, @@ -147,15 +109,6 @@ class VariableType(Enum): {"name": "g_Ca_L_Centre_0DCapable", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, {"name": "g_Ca_L_Periphery_0DCapable", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, {"name": "E_Ca_L", "units": "millivolt", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "d_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_d_L", "units": "second", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_d_L", "units": "per_second", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_d_L", "units": "per_second", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "f_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_f_L", "units": "second", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_f_L", "units": "per_second", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_f_L", "units": "per_second", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "g_Ca_T", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Ca_T_Centre_Published", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, {"name": "g_Ca_T_Periphery_Published", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, {"name": "g_Ca_T_Centre_1DCapable", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, @@ -163,69 +116,115 @@ class VariableType(Enum): {"name": "g_Ca_T_Centre_0DCapable", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, {"name": "g_Ca_T_Periphery_0DCapable", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, {"name": "E_Ca_T", "units": "millivolt", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "d_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_d_T", "units": "second", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_d_T", "units": "per_second", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_d_T", "units": "per_second", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "f_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_f_T", "units": "second", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_f_T", "units": "per_second", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_f_T", "units": "per_second", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "g_to", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_to_Centre_Published", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, {"name": "g_to_Periphery_Published", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, {"name": "g_to_Centre_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, {"name": "g_to_Periphery_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, {"name": "g_to_Centre_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, {"name": "g_to_Periphery_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_sus", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_sus_Centre_Published", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, {"name": "g_sus_Periphery_Published", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, {"name": "g_sus_Centre_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, {"name": "g_sus_Periphery_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, {"name": "g_sus_Centre_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, {"name": "g_sus_Periphery_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "q_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_q_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_q", "units": "second", "component": "four_AP_sensitive_currents_q_gate", "type": VariableType.ALGEBRAIC}, - {"name": "r_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_r_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_r", "units": "second", "component": "four_AP_sensitive_currents_r_gate", "type": VariableType.ALGEBRAIC}, - {"name": "g_K_r", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_K_r_Centre_Published", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, {"name": "g_K_r_Periphery_Published", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, {"name": "g_K_r_Centre_1DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, {"name": "g_K_r_Periphery_1DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, {"name": "g_K_r_Centre_0DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, {"name": "g_K_r_Periphery_0DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "P_a", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.ALGEBRAIC}, - {"name": "P_af_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_P_af", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate", "type": VariableType.ALGEBRAIC}, - {"name": "P_as_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_P_as", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_P_i", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "P_i_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate", "type": VariableType.ALGEBRAIC}, - {"name": "g_K_s", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_K_s_Centre_Published", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, {"name": "g_K_s_Periphery_Published", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, {"name": "g_K_s_Centre_1DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, {"name": "g_K_s_Periphery_1DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, {"name": "g_K_s_Centre_0DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, {"name": "g_K_s_Periphery_0DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "alpha_xs", "units": "per_second", "component": "slow_delayed_rectifying_potassium_current_xs_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_xs", "units": "per_second", "component": "slow_delayed_rectifying_potassium_current_xs_gate", "type": VariableType.ALGEBRAIC}, - {"name": "g_f_Na", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_f_Na_Centre_Published", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_Na_Periphery_Published", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_Na_Centre_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_Na_Periphery_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_Na_Centre_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_Na_Periphery_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_K", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_f_K_Centre_Published", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_K_Periphery_Published", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_K_Centre_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_K_Periphery_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_K_Centre_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_K_Periphery_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, + {"name": "FCell", "units": "dimensionless", "component": "membrane", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "Cm", "units": "microF", "component": "membrane", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_Ca_p", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_b_Na", "units": "microS", "component": "sodium_background_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_b_K", "units": "microS", "component": "potassium_background_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_b_Ca", "units": "microS", "component": "calcium_background_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Ca", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "k_NaCa", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_p_max", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_Ca_p_max", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K_s", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_Na", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_Ca_L", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_Ca_T", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_to", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_sus", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_K_r", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "tau_P_i", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_K_s", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_f_Na", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_f_K", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_Na", "units": "nanoA", "component": "sodium_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_p", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.ALGEBRAIC}, + {"name": "i_NaCa", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.ALGEBRAIC}, + {"name": "i_b_K", "units": "nanoA", "component": "potassium_background_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_b_Ca", "units": "nanoA", "component": "calcium_background_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_b_Na", "units": "nanoA", "component": "sodium_background_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_f_K", "units": "nanoA", "component": "hyperpolarisation_activated_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_f_Na", "units": "nanoA", "component": "hyperpolarisation_activated_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_K_s", "units": "nanoA", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_K_r", "units": "nanoA", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_sus", "units": "nanoA", "component": "four_AP_sensitive_currents", "type": VariableType.ALGEBRAIC}, + {"name": "i_to", "units": "nanoA", "component": "four_AP_sensitive_currents", "type": VariableType.ALGEBRAIC}, + {"name": "i_Ca_T", "units": "nanoA", "component": "T_type_Ca_channel", "type": VariableType.ALGEBRAIC}, + {"name": "i_Ca_L", "units": "nanoA", "component": "L_type_Ca_channel", "type": VariableType.ALGEBRAIC}, + {"name": "h", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, + {"name": "m_infinity", "units": "dimensionless", "component": "sodium_current_m_gate", "type": VariableType.ALGEBRAIC}, + {"name": "tau_m", "units": "second", "component": "sodium_current_m_gate", "type": VariableType.ALGEBRAIC}, + {"name": "F_Na", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, + {"name": "h1_infinity", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, + {"name": "tau_h1", "units": "second", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, + {"name": "h2_infinity", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, + {"name": "tau_h2", "units": "second", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, + {"name": "d_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, + {"name": "tau_d_L", "units": "second", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, + {"name": "alpha_d_L", "units": "per_second", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_d_L", "units": "per_second", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, + {"name": "f_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, + {"name": "tau_f_L", "units": "second", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, + {"name": "alpha_f_L", "units": "per_second", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_f_L", "units": "per_second", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, + {"name": "d_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, + {"name": "tau_d_T", "units": "second", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, + {"name": "alpha_d_T", "units": "per_second", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_d_T", "units": "per_second", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, + {"name": "f_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, + {"name": "tau_f_T", "units": "second", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, + {"name": "alpha_f_T", "units": "per_second", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_f_T", "units": "per_second", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, + {"name": "q_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_q_gate", "type": VariableType.ALGEBRAIC}, + {"name": "tau_q", "units": "second", "component": "four_AP_sensitive_currents_q_gate", "type": VariableType.ALGEBRAIC}, + {"name": "r_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_r_gate", "type": VariableType.ALGEBRAIC}, + {"name": "tau_r", "units": "second", "component": "four_AP_sensitive_currents_r_gate", "type": VariableType.ALGEBRAIC}, + {"name": "P_a", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.ALGEBRAIC}, + {"name": "P_af_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate", "type": VariableType.ALGEBRAIC}, + {"name": "tau_P_af", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate", "type": VariableType.ALGEBRAIC}, + {"name": "P_as_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate", "type": VariableType.ALGEBRAIC}, + {"name": "tau_P_as", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate", "type": VariableType.ALGEBRAIC}, + {"name": "P_i_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate", "type": VariableType.ALGEBRAIC}, + {"name": "alpha_xs", "units": "per_second", "component": "slow_delayed_rectifying_potassium_current_xs_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_xs", "units": "per_second", "component": "slow_delayed_rectifying_potassium_current_xs_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_y", "units": "per_second", "component": "hyperpolarisation_activated_current_y_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_y", "units": "per_second", "component": "hyperpolarisation_activated_current_y_gate", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index cd52f7451..1d4908a13 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -9,10 +9,10 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 18; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_COUNT = 9; +const size_t EXTERNAL_COUNT = 1; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -24,24 +24,24 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", EXTERNAL}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, + {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, + {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, + {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"i_Stim", "microA_per_cm2", "membrane", EXTERNAL} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index a741566be..5a01f6f0a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -8,10 +8,10 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 18 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_COUNT = 9 +EXTERNAL_COUNT = 1 class VariableType(Enum): @@ -33,24 +33,24 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index f687edd86..68474ef4f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 18; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_COUNT = 10; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -24,22 +23,22 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, + {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, + {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, + {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, + {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} }; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index c56e1e8f4..69c72fb83 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -9,10 +9,10 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 18; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 2; +const size_t ALGEBRAIC_COUNT = 10; +const size_t EXTERNAL_COUNT = 1; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -24,24 +24,24 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, - {"E_L", "millivolt", "leakage_current", EXTERNAL}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, + {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, + {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, + {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"E_L", "millivolt", "leakage_current", EXTERNAL} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 796983378..39e9f1d65 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -8,10 +8,10 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 18 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 2 +ALGEBRAIC_COUNT = 10 +EXTERNAL_COUNT = 1 class VariableType(Enum): @@ -33,24 +33,24 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.EXTERNAL}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 1cc4901fd..d9d05dbab 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -9,10 +9,10 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 18; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 4; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_COUNT = 10; +const size_t EXTERNAL_COUNT = 1; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -24,24 +24,24 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { + {"E_R", "millivolt", "membrane", CONSTANT}, + {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, + {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, + {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"Cm", "microF_per_cm2", "membrane", EXTERNAL}, - {"E_R", "millivolt", "membrane", CONSTANT}, - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"Cm", "microF_per_cm2", "membrane", EXTERNAL} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index b78d3d588..3749793d0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -8,10 +8,10 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 18 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 4 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_COUNT = 10 +EXTERNAL_COUNT = 1 class VariableType(Enum): @@ -33,24 +33,24 @@ class VariableType(Enum): ] VARIABLE_INFO = [ + {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL}, - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index cfcaf93f2..4048ffd58 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 18; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_COUNT = 10; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -24,22 +23,22 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, + {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, + {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, + {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, + {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} }; @@ -491,22 +490,22 @@ void findRoot16(double voi, double *states, double *rates, double *variables) void initialiseVariables(double *states, double *rates, double *constants) { - algebraic[0] = 0.0; - algebraic[1] = 0.0; - algebraic[2] = 0.0; - algebraic[3] = 0.0; constants[0] = 1.0; constants[1] = 0.0; - computedConstants[0] = 0.0; constants[2] = 0.3; - computedConstants[1] = 0.0; constants[3] = 120.0; + constants[4] = 36.0; + computedConstants[0] = 0.0; + computedConstants[1] = 0.0; + computedConstants[2] = 0.0; + algebraic[0] = 0.0; + algebraic[1] = 0.0; + algebraic[2] = 0.0; + algebraic[3] = 0.0; algebraic[4] = 0.0; algebraic[5] = 0.0; algebraic[6] = 0.0; algebraic[7] = 0.0; - computedConstants[2] = 0.0; - constants[4] = 36.0; algebraic[8] = 0.0; algebraic[9] = 0.0; states[0] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index be76c88f6..2379ada7d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index fbc3704f8..cbeb56196 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 18 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_COUNT = 10 class VariableType(Enum): @@ -32,22 +31,22 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} ] @@ -434,22 +433,22 @@ def find_root_16(voi, states, rates, variables): def initialise_variables(states, rates, constants): - algebraic[0] = 0.0 - algebraic[1] = 0.0 - algebraic[2] = 0.0 - algebraic[3] = 0.0 constants[0] = 1.0 constants[1] = 0.0 - computed_constants[0] = 0.0 constants[2] = 0.3 - computed_constants[1] = 0.0 constants[3] = 120.0 + constants[4] = 36.0 + computed_constants[0] = 0.0 + computed_constants[1] = 0.0 + computed_constants[2] = 0.0 + algebraic[0] = 0.0 + algebraic[1] = 0.0 + algebraic[2] = 0.0 + algebraic[3] = 0.0 algebraic[4] = 0.0 algebraic[5] = 0.0 algebraic[6] = 0.0 algebraic[7] = 0.0 - computed_constants[2] = 0.0 - constants[4] = 36.0 algebraic[8] = 0.0 algebraic[9] = 0.0 states[0] = 0.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 2da76b8e8..e38ef8855 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -9,10 +9,10 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 18; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_COUNT = 8; +const size_t EXTERNAL_COUNT = 2; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -24,23 +24,23 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", EXTERNAL}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, + {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, + {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, + {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"i_Stim", "microA_per_cm2", "membrane", EXTERNAL}, {"beta_n", "per_millisecond", "potassium_channel_n_gate", EXTERNAL} }; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 4a645f071..98ab308f3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -8,10 +8,10 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 18 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_COUNT = 8 +EXTERNAL_COUNT = 2 class VariableType(Enum): @@ -33,23 +33,23 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL}, {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 50798a796..91f595dd0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -9,10 +9,10 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 4; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 18; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 12; +const size_t EXTERNAL_COUNT = 2; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -24,24 +24,24 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { + {"Cm", "microF_per_cm2", "membrane", CONSTANT}, + {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, + {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"Cm", "microF_per_cm2", "membrane", CONSTANT}, - {"E_R", "millivolt", "membrane", EXTERNAL}, {"E_L", "millivolt", "leakage_current", ALGEBRAIC}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"E_Na", "millivolt", "sodium_channel", ALGEBRAIC}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"E_K", "millivolt", "potassium_channel", EXTERNAL}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"E_R", "millivolt", "membrane", EXTERNAL}, + {"E_K", "millivolt", "potassium_channel", EXTERNAL} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index e83d4154e..7785dba58 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -8,10 +8,10 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 4 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 18 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 12 +EXTERNAL_COUNT = 2 class VariableType(Enum): @@ -33,24 +33,24 @@ class VariableType(Enum): ] VARIABLE_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.EXTERNAL}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index c608b0c7f..3193041ba 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -9,10 +9,10 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 18; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 3; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_COUNT = 10; +const size_t EXTERNAL_COUNT = 2; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -24,24 +24,24 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { + {"E_R", "millivolt", "membrane", CONSTANT}, + {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, + {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"Cm", "microF_per_cm2", "membrane", EXTERNAL}, - {"E_R", "millivolt", "membrane", CONSTANT}, - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", EXTERNAL}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"Cm", "microF_per_cm2", "membrane", EXTERNAL}, + {"g_Na", "milliS_per_cm2", "sodium_channel", EXTERNAL} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 81364cfcb..49f7f8bcb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -8,10 +8,10 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 18 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 3 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_COUNT = 10 +EXTERNAL_COUNT = 2 class VariableType(Enum): @@ -33,24 +33,24 @@ class VariableType(Enum): ] VARIABLE_INFO = [ + {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL}, - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.EXTERNAL}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 5627364ba..a36578b7b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -9,10 +9,10 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 20; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_COUNT = 10; +const size_t EXTERNAL_COUNT = 2; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -22,26 +22,26 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"V", "millivolt", "membrane", EXTERNAL}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"m", "dimensionless", "sodium_channel_m_gate", EXTERNAL}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, + {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, + {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, + {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, + {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"V", "millivolt", "membrane", EXTERNAL}, + {"m", "dimensionless", "sodium_channel_m_gate", EXTERNAL} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index d887340c1..10b92a843 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -8,10 +8,10 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 20 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_COUNT = 10 +EXTERNAL_COUNT = 2 class VariableType(Enum): @@ -31,26 +31,26 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.EXTERNAL}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 329a24f94..3cb02dcd1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -9,10 +9,10 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 3; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 19; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_COUNT = 8; +const size_t EXTERNAL_COUNT = 3; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -23,25 +23,25 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"V", "millivolt", "membrane", EXTERNAL}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", EXTERNAL}, {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, + {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, + {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, + {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", EXTERNAL}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"V", "millivolt", "membrane", EXTERNAL}, + {"i_Na", "microA_per_cm2", "sodium_channel", EXTERNAL}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate", EXTERNAL} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 019a0c857..1f15be90f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -8,10 +8,10 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 3 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 19 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_COUNT = 8 +EXTERNAL_COUNT = 3 class VariableType(Enum): @@ -32,25 +32,25 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.EXTERNAL}, {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.EXTERNAL}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.EXTERNAL}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index be76c88f6..2379ada7d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index b37f2884e..de38477e3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 18 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_COUNT = 10 class VariableType(Enum): @@ -32,22 +31,22 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 1f5098cc5..a1ec41db7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -9,10 +9,10 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 3; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 19; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 3; +const size_t ALGEBRAIC_COUNT = 10; +const size_t EXTERNAL_COUNT = 1; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -23,25 +23,25 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"m", "dimensionless", "sodium_channel_m_gate", EXTERNAL}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, + {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, + {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, + {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, + {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"m", "dimensionless", "sodium_channel_m_gate", EXTERNAL} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index b68a159ff..2ed93ed11 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -8,10 +8,10 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 3 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 19 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 3 +ALGEBRAIC_COUNT = 10 +EXTERNAL_COUNT = 1 class VariableType(Enum): @@ -32,25 +32,25 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.EXTERNAL}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index b2b3956e7..01b9013b6 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 17; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 12; const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; @@ -24,15 +23,15 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"i_Leak", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"E_L", "millivolt", "leakage_current", CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", ALGEBRAIC}, {"g_Na_max", "milliS_per_cm2", "sodium_channel", CONSTANT}, {"E_Na", "millivolt", "sodium_channel", CONSTANT}, + {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, + {"i_Leak", "microA_per_cm2", "leakage_current", ALGEBRAIC}, + {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, + {"g_Na", "milliS_per_cm2", "sodium_channel", ALGEBRAIC}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index 8149205d0..a4c365da2 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 8fb96500a..4eb81b090 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 4 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 17 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 12 class VariableType(Enum): @@ -32,15 +31,15 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Leak", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "g_Na_max", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.CONSTANT}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, + {"name": "i_Leak", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 4e9479368..1eadd4672 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -10,9 +10,8 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index cc72c5b3a..3f1fb63fd 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 4c7b0bfdf..6de2a7b40 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -9,9 +9,8 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 9462cd1de..35629691c 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -10,9 +10,8 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index 89890cfa6..ca79cc5f2 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index ff803cc8f..48b38de07 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -9,9 +9,8 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index 6c6342e78..7324a50b7 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index cc72c5b3a..3f1fb63fd 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 283bdd003..913f34ea2 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index 0b0fb3bb3..2e3fe1c55 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index 89890cfa6..ca79cc5f2 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 986a9feb1..65e03adfd 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index 83124f7ed..71e7ea5a8 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -12,7 +12,6 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index cc72c5b3a..3f1fb63fd 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index 00b49ef0f..bc525feb5 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -11,7 +11,6 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 -EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 997ae718f..a37c8889b 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -12,7 +12,6 @@ const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index 89890cfa6..ca79cc5f2 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index 72fd031fc..22311d1da 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -11,7 +11,6 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 -EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 6d83c015c..d8bbbf62a 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index 14013eaef..cc74aaa0b 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 9f9df39e8..a6af28cef 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 21f46b37f..9ce2fe018 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index 2c7d5a183..f0d48d38d 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index b4fff77d2..faa79d322 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 461288218..82e57fc2d 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index d4cb731d4..0b0953abe 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 67babcba7..2a5ff0d6c 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index e46429232..0b29e548b 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -12,7 +12,6 @@ const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const size_t EXTERNAL_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index cc72c5b3a..3f1fb63fd 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index a19fdebbf..2f19ddc26 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -11,7 +11,6 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 -EXTERNAL_COUNT = 0 class VariableType(Enum): diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 63de63a9f..81baaa83c 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 2; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 3; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 5; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; @@ -24,8 +23,8 @@ const VariableInfo STATE_INFO[] = { const VariableInfo VARIABLE_INFO[] = { {"k1", "dimensionless", "main", CONSTANT}, {"k3", "dimensionless", "main", CONSTANT}, - {"y3", "dimensionless", "main", ALGEBRAIC}, {"k2", "dimensionless", "main", CONSTANT}, + {"y3", "dimensionless", "main", ALGEBRAIC}, {"y2_scaled", "dimensionless", "main", ALGEBRAIC} }; @@ -94,8 +93,8 @@ void initialiseVariables(double *states, double *rates, double *constants) { constants[0] = 0.04; constants[1] = 1.0e4; - algebraic[0] = 0.0; constants[2] = 3.0e7; + algebraic[0] = 0.0; states[0] = 1.0; states[1] = 0.0; } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index 653f64a63..bca2cef3a 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index b5f40fc30..8a4f383de 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 2 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 3 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 5 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 2 class VariableType(Enum): @@ -32,8 +31,8 @@ class VariableType(Enum): VARIABLE_INFO = [ {"name": "k1", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, {"name": "k3", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, - {"name": "y3", "units": "dimensionless", "component": "main", "type": VariableType.ALGEBRAIC}, {"name": "k2", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, + {"name": "y3", "units": "dimensionless", "component": "main", "type": VariableType.ALGEBRAIC}, {"name": "y2_scaled", "units": "dimensionless", "component": "main", "type": VariableType.ALGEBRAIC} ] @@ -73,8 +72,8 @@ def find_root_0(voi, states, rates, variables): def initialise_variables(states, rates, constants): constants[0] = 0.04 constants[1] = 1.0e4 - algebraic[0] = 0.0 constants[2] = 3.0e7 + algebraic[0] = 0.0 states[0] = 1.0 states[1] = 0.0 diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 0bc157d92..7bbd363e0 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 3; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 3; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 4; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index 653f64a63..bca2cef3a 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index f96e5d878..2aaab1f03 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 3 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 3 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 4 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 1 class VariableType(Enum): diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 02fb665ff..0c1602c01 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 10; -const size_t EXTERNAL_COUNT = 0; +const size_t CONSTANT_COUNT = 2; +const size_t COMPUTED_CONSTANT_COUNT = 5; +const size_t ALGEBRAIC_COUNT = 3; const VariableInfo VOI_INFO = {"x", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; @@ -21,15 +20,15 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo VARIABLE_INFO[] = { - {"sin", "dimensionless", "actual_sin", ALGEBRAIC}, {"deriv_approx_initial_value", "dimensionless", "main", CONSTANT}, - {"sin", "dimensionless", "parabolic_approx_sin", ALGEBRAIC}, {"C", "dimensionless", "main", CONSTANT}, {"k2_oPi", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, {"k2Pi", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, {"kPi_2", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, {"kPi", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, {"kPi_32", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, + {"sin", "dimensionless", "actual_sin", ALGEBRAIC}, + {"sin", "dimensionless", "parabolic_approx_sin", ALGEBRAIC}, {"z", "dimensionless", "parabolic_approx_sin", ALGEBRAIC} }; diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index ad2862fae..93c965f33 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 4c559e5e1..8119f9805 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 10 -EXTERNAL_COUNT = 0 +CONSTANT_COUNT = 2 +COMPUTED_CONSTANT_COUNT = 5 +ALGEBRAIC_COUNT = 3 class VariableType(Enum): @@ -29,15 +28,15 @@ class VariableType(Enum): ] VARIABLE_INFO = [ - {"name": "sin", "units": "dimensionless", "component": "actual_sin", "type": VariableType.ALGEBRAIC}, {"name": "deriv_approx_initial_value", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, - {"name": "sin", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.ALGEBRAIC}, {"name": "C", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, {"name": "k2_oPi", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, {"name": "k2Pi", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, {"name": "kPi_2", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, {"name": "kPi", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, {"name": "kPi_32", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "sin", "units": "dimensionless", "component": "actual_sin", "type": VariableType.ALGEBRAIC}, + {"name": "sin", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.ALGEBRAIC}, {"name": "z", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 015da83af..9a6fb704d 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -8,13 +8,12 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 8; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 10; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 1; +const size_t EXTERNAL_COUNT = 1; const VariableInfo VARIABLE_INFO[] = { - {"v", "fmol_per_sec", "SLC_template3_ss", ALGEBRAIC}, {"E", "fmol", "SLC_template3_ss", CONSTANT}, {"P_0", "per_fmol_sec4", "SLC_template3_ss", CONSTANT}, {"q_Ao", "fmol", "SLC_template3_ss", CONSTANT}, @@ -23,6 +22,7 @@ const VariableInfo VARIABLE_INFO[] = { {"P_2", "per_fmol_sec3", "SLC_template3_ss", CONSTANT}, {"P_5", "per_sec3", "SLC_template3_ss", CONSTANT}, {"P_4", "per_fmol2_sec3", "SLC_template3_ss", CONSTANT}, + {"v", "fmol_per_sec", "SLC_template3_ss", ALGEBRAIC}, {"P_3", "per_fmol_sec3", "SLC_template3_ss", EXTERNAL} }; diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index e09f76a95..67a0315a5 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -7,10 +7,10 @@ __version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 8 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 10 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 1 +EXTERNAL_COUNT = 1 class VariableType(Enum): @@ -21,7 +21,6 @@ class VariableType(Enum): VARIABLE_INFO = [ - {"name": "v", "units": "fmol_per_sec", "component": "SLC_template3_ss", "type": VariableType.ALGEBRAIC}, {"name": "E", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "q_Ao", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, @@ -30,6 +29,7 @@ class VariableType(Enum): {"name": "P_2", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, + {"name": "v", "units": "fmol_per_sec", "component": "SLC_template3_ss", "type": VariableType.ALGEBRAIC}, {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 004fa4ce5..bf4de6ab2 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -9,10 +9,9 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; -const size_t CONSTANT_COUNT = 0; +const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "component_1", VARIABLE_OF_INTEGRATION}; diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index 890a583bb..340f578dd 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -11,7 +11,6 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; typedef enum { VARIABLE_OF_INTEGRATION, diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 0c4afd730..491332bdf 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -8,10 +8,9 @@ LIBCELLML_VERSION = "0.5.0" STATE_COUNT = 1 -CONSTANT_COUNT = 0 +CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 0 +ALGEBRAIC_COUNT = 0 class VariableType(Enum): From 7c0d8a1e2b205449d0f9db80020cba24399f38e0 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 9 Aug 2024 16:05:57 +0200 Subject: [PATCH 18/74] AnalyserEquation: keep track of states and constants. --- cmake/common.cmake | 10 ++++ src/CMakeLists.txt | 10 +--- src/analyser.cpp | 8 +-- src/analyserequation.cpp | 55 +++++++++++++----- src/analyserequation_p.h | 2 + src/api/libcellml/analyserequation.h | 58 +++++++++++++++++++ src/bindings/interface/analyserequation.i | 18 ++++++ src/bindings/javascript/analyserequation.cpp | 6 ++ src/debug.cpp | 48 +++++++++++---- src/generator.cpp | 46 +++++---------- src/utilities.cpp | 33 ++++++++++- .../javascript/analyserequation.test.js | 6 +- .../model.three.externals.h | 6 +- 13 files changed, 230 insertions(+), 76 deletions(-) diff --git a/cmake/common.cmake b/cmake/common.cmake index 6939ca93b..214be6d69 100644 --- a/cmake/common.cmake +++ b/cmake/common.cmake @@ -313,3 +313,13 @@ function(redhat_based _RESULT) endif() set(${_RESULT} ${_REDHAT_BASED} PARENT_SCOPE) endfunction() + +function(apply_libxml2_settings _TARGET) + if(HAVE_LIBXML2_CONFIG) + target_link_libraries(${_TARGET} PUBLIC ${LIBXML2_TARGET_NAME}) + else() + target_include_directories(${_TARGET} PUBLIC ${LIBXML2_INCLUDE_DIR} ${ZLIB_INCLUDE_DIRS}) + target_link_libraries(${_TARGET} PUBLIC ${LIBXML2_LIBRARIES} ${ZLIB_LIBRARIES}) + target_compile_definitions(${_TARGET} PUBLIC ${LIBXML2_DEFINITIONS}) + endif() +endfunction() diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 30a60d5bc..eb748bf9a 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -193,13 +193,7 @@ else() target_include_directories(cellml PUBLIC ${ZLIB_INCLUDE_DIRS}) endif() -if(HAVE_LIBXML2_CONFIG) - target_link_libraries(cellml PUBLIC ${LIBXML2_TARGET_NAME}) -else() - target_include_directories(cellml PUBLIC ${LIBXML2_INCLUDE_DIR} ${ZLIB_INCLUDE_DIRS}) - target_link_libraries(cellml PUBLIC ${LIBXML2_LIBRARIES} ${ZLIB_LIBRARIES}) - target_compile_definitions(cellml PUBLIC ${LIBXML2_DEFINITIONS}) -endif() +apply_libxml2_settings(cellml) # Use target compile features to propagate features to consuming projects. target_compile_features(cellml PUBLIC cxx_std_17) @@ -231,6 +225,8 @@ target_include_directories(cellml_debug_utilities $ ) +apply_libxml2_settings(cellml_debug_utilities) + set_target_properties(cellml_debug_utilities PROPERTIES CXX_VISIBILITY_PRESET hidden DEBUG_POSTFIX d diff --git a/src/analyser.cpp b/src/analyser.cpp index f0caa7b86..592ef5730 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -2509,8 +2509,8 @@ bool Analyser::AnalyserImpl::isStateRateBased(const AnalyserEquationPtr &equatio if ((dependency->type() == AnalyserEquation::Type::ODE) || ((dependency->type() == AnalyserEquation::Type::NLA) - && (dependency->algebraicCount() == 1) - && (dependency->algebraic(0)->type() == AnalyserVariable::Type::STATE)) + && (dependency->stateCount() == 1) + && (dependency->state(0)->type() == AnalyserVariable::Type::STATE)) || isStateRateBased(dependency, checkedEquations)) { return true; } @@ -3301,11 +3301,11 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) switch (variable->type()) { case AnalyserVariable::Type::STATE: - equation->mPimpl->mAlgebraic.push_back(variable); //---GRY--- equation->mPimpl->mStates.push_back(variable); + equation->mPimpl->mStates.push_back(variable); break; case AnalyserVariable::Type::CONSTANT: - equation->mPimpl->mAlgebraic.push_back(variable); //---GRY--- equation->mPimpl->mConstants.push_back(variable); + equation->mPimpl->mConstants.push_back(variable); break; case AnalyserVariable::Type::COMPUTED_CONSTANT: diff --git a/src/analyserequation.cpp b/src/analyserequation.cpp index 7caf807ce..d5d13f9f3 100644 --- a/src/analyserequation.cpp +++ b/src/analyserequation.cpp @@ -20,6 +20,7 @@ limitations under the License. #include #include "analyserequation_p.h" +#include "utilities.h" namespace libcellml { @@ -30,21 +31,9 @@ AnalyserEquationPtr AnalyserEquation::AnalyserEquationImpl::create() bool AnalyserEquation::AnalyserEquationImpl::isEmptyDependency(const AnalyserEquationWeakPtr &dependency) { - auto computedConstants = dependency.lock()->computedConstants(); + auto variables = libcellml::variables(dependency.lock()); - if (std::any_of(computedConstants.begin(), computedConstants.end(), [](const auto &v) { return v != nullptr; })) { - return false; - } - - auto algebraic = dependency.lock()->algebraic(); - - if (std::any_of(algebraic.begin(), algebraic.end(), [](const auto &v) { return v != nullptr; })) { - return false; - } - - auto externals = dependency.lock()->externals(); - - if (std::any_of(externals.begin(), externals.end(), [](const auto &v) { return v != nullptr; })) { + if (std::any_of(variables.begin(), variables.end(), [](const auto &v) { return v != nullptr; })) { return false; } @@ -149,6 +138,44 @@ bool AnalyserEquation::isStateRateBased() const return mPimpl->mIsStateRateBased; } +size_t AnalyserEquation::stateCount() const +{ + return mPimpl->mStates.size(); +} + +std::vector AnalyserEquation::states() const +{ + return mPimpl->mStates; +} + +AnalyserVariablePtr AnalyserEquation::state(size_t index) const +{ + if (index >= mPimpl->mStates.size()) { + return {}; + } + + return mPimpl->mStates[index]; +} + +size_t AnalyserEquation::constantCount() const +{ + return mPimpl->mConstants.size(); +} + +std::vector AnalyserEquation::constants() const +{ + return mPimpl->mConstants; +} + +AnalyserVariablePtr AnalyserEquation::constant(size_t index) const +{ + if (index >= mPimpl->mConstants.size()) { + return {}; + } + + return mPimpl->mConstants[index]; +} + size_t AnalyserEquation::computedConstantCount() const { return mPimpl->mComputedConstants.size(); diff --git a/src/analyserequation_p.h b/src/analyserequation_p.h index 471fd9b97..d0a167f4a 100644 --- a/src/analyserequation_p.h +++ b/src/analyserequation_p.h @@ -34,6 +34,8 @@ struct AnalyserEquation::AnalyserEquationImpl size_t mNlaSystemIndex; bool mIsStateRateBased = false; + std::vector mStates; + std::vector mConstants; std::vector mComputedConstants; std::vector mAlgebraic; std::vector mExternals; diff --git a/src/api/libcellml/analyserequation.h b/src/api/libcellml/analyserequation.h index 22d7d5067..9c83fa402 100644 --- a/src/api/libcellml/analyserequation.h +++ b/src/api/libcellml/analyserequation.h @@ -165,6 +165,64 @@ class LIBCELLML_EXPORT AnalyserEquation */ bool isStateRateBased() const; + /** + * @brief Get the number of states computed by this @ref AnalyserEquation. + * + * Return the number of states computed by this @ref AnalyserEquation. + * + * @return The number of states. + */ + size_t stateCount() const; + + /** + * @brief Get the states computed by this @ref AnalyserEquation. + * + * Return the states computed by this @ref AnalyserEquation. + * + * @return The states as a @c std::vector. + */ + std::vector states() const; + + /** + * @brief Get the state, at @p index, computed by this @ref AnalyserEquation. + * + * Return the state, at @p index, computed by this @ref AnalyserEquation. + * + * @param index The index of the state to return. + * + * @return The state, at @p index, on success, @c nullptr on failure. + */ + AnalyserVariablePtr state(size_t index) const; + + /** + * @brief Get the number of constant computed by this @ref AnalyserEquation. + * + * Return the number of constants computed by this @ref AnalyserEquation. + * + * @return The number of constants. + */ + size_t constantCount() const; + + /** + * @brief Get the constants computed by this @ref AnalyserEquation. + * + * Return the constants computed by this @ref AnalyserEquation. + * + * @return The constants as a @c std::vector. + */ + std::vector constants() const; + + /** + * @brief Get the constant, at @p index, computed by this @ref AnalyserEquation. + * + * Return the constant, at @p index, computed by this @ref AnalyserEquation. + * + * @param index The index of the constant to return. + * + * @return The constant, at @p index, on success, @c nullptr on failure. + */ + AnalyserVariablePtr constant(size_t index) const; + /** * @brief Get the number of computed constants computed by this @ref AnalyserEquation. * diff --git a/src/bindings/interface/analyserequation.i b/src/bindings/interface/analyserequation.i index 8749557bb..3e7f3345b 100644 --- a/src/bindings/interface/analyserequation.i +++ b/src/bindings/interface/analyserequation.i @@ -43,6 +43,24 @@ %feature("docstring") libcellml::AnalyserEquation::isStateRateBased "Tests if this :class:`AnalyserEquation` object relies on states and/or rates."; +%feature("docstring") libcellml::AnalyserEquation::stateCount +"Returns the number of states computed by this :class:`AnalyserEquation` object."; + +%feature("docstring") libcellml::AnalyserEquation::states +"Returns the states computed by this :class:`AnalyserEquation` object."; + +%feature("docstring") libcellml::AnalyserEquation::state +"Returns the state, at the given index, computed by this :class:`AnalyserEquation` object."; + +%feature("docstring") libcellml::AnalyserEquation::constantCount +"Returns the number of constants computed by this :class:`AnalyserEquation` object."; + +%feature("docstring") libcellml::AnalyserEquation::constants +"Returns the constants computed by this :class:`AnalyserEquation` object."; + +%feature("docstring") libcellml::AnalyserEquation::constant +"Returns the constant, at the given index, computed by this :class:`AnalyserEquation` object."; + %feature("docstring") libcellml::AnalyserEquation::computedConstantCount "Returns the number of computed constants computed by this :class:`AnalyserEquation` object."; diff --git a/src/bindings/javascript/analyserequation.cpp b/src/bindings/javascript/analyserequation.cpp index 3b1bf0a46..ed04c4c13 100644 --- a/src/bindings/javascript/analyserequation.cpp +++ b/src/bindings/javascript/analyserequation.cpp @@ -45,6 +45,12 @@ EMSCRIPTEN_BINDINGS(libcellml_analyserequation) .function("nlaSiblings", &libcellml::AnalyserEquation::nlaSiblings) .function("nlaSibling", &libcellml::AnalyserEquation::nlaSibling) .function("isStateRateBased", &libcellml::AnalyserEquation::isStateRateBased) + .function("stateCount", &libcellml::AnalyserEquation::stateCount) + .function("states", select_overload() const>(&libcellml::AnalyserEquation::states)) + .function("state", select_overload(&libcellml::AnalyserEquation::state)) + .function("constantCount", &libcellml::AnalyserEquation::constantCount) + .function("constants", select_overload() const>(&libcellml::AnalyserEquation::constants)) + .function("constant", select_overload(&libcellml::AnalyserEquation::constant)) .function("computedConstantCount", &libcellml::AnalyserEquation::computedConstantCount) .function("computedConstants", &libcellml::AnalyserEquation::computedConstants) .function("computedConstant", &libcellml::AnalyserEquation::computedConstant) diff --git a/src/debug.cpp b/src/debug.cpp index 179a80935..a1a92ac88 100644 --- a/src/debug.cpp +++ b/src/debug.cpp @@ -26,9 +26,10 @@ limitations under the License. #include "libcellml/model.h" #include "libcellml/variable.h" -#include "libcellml/undefines.h" - #include "commonutils.h" +#include "utilities.h" + +#include "libcellml/undefines.h" namespace libcellml { @@ -85,6 +86,26 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) Debug() << "\nType: " << AnalyserEquation::typeAsString(eqn->type()); + if (eqn->stateCount() != 0) { + Debug() << "\nStates:"; + + for (const auto &var : eqn->states()) { + Debug() << " - " << var->variable()->name(); + } + } else { + Debug() << "\nNo states"; + } + + if (eqn->constantCount() != 0) { + Debug() << "\nConstants:"; + + for (const auto &var : eqn->constants()) { + Debug() << " - " << var->variable()->name(); + } + } else { + Debug() << "\nNo constants"; + } + if (eqn->computedConstantCount() != 0) { Debug() << "\nComputed constants:"; @@ -105,6 +126,16 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) Debug() << "\nNo algebraic variables"; } + if (eqn->algebraicCount() != 0) { + Debug() << "\nExternal variables:"; + + for (const auto &var : eqn->externals()) { + Debug() << " - " << var->variable()->name(); + } + } else { + Debug() << "\nNo external variables"; + } + if (eqn->dependencyCount() != 0) { Debug() << "\nDependencies:"; @@ -112,7 +143,7 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) if (dep->ast() != nullptr) { Debug() << " - " << astAsCode(dep->ast()); } else if (dep->type() == AnalyserEquation::Type::EXTERNAL) { - Debug() << " - External equation for '" << dep->algebraic(0)->variable()->name() << "'"; + Debug() << " - External equation for '" << dep->external(0)->variable()->name() << "'"; } else { Debug() << " - ??? [" << AnalyserEquation::typeAsString(dep->type()) << "]"; } @@ -143,11 +174,11 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) Debug() << "\n---------------------------------------[END]\n"; } -void printAnalyserModelVariables(const std::vector &variables) +void printAnalyserModelVariables(const AnalyserModelPtr &model) { size_t varNb = 0; - for (const auto &var : variables) { + for (const auto &var : variables(model)) { Debug() << "\n---------------------------------------[API variable #" << ++varNb << "]"; Debug() << "\nName: " << var->variable()->name(); Debug() << "Type: " << AnalyserVariable::typeAsString(var->type()); @@ -170,13 +201,6 @@ void printAnalyserModelVariables(const std::vector &variabl } } -void printAnalyserModelVariables(const AnalyserModelPtr &model) -{ - printAnalyserModelVariables(model->constants()); - printAnalyserModelVariables(model->computedConstants()); - printAnalyserModelVariables(model->algebraic()); -} - void printHistory(const History &history) { for (const auto &h : history) { diff --git a/src/generator.cpp b/src/generator.cpp index 44671415e..4a280ce43 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -92,11 +92,7 @@ AnalyserVariablePtr Generator::GeneratorImpl::analyserVariable(const VariablePtr && mModel->areEquivalentVariables(variable, modelVoiVariable)) { res = modelVoi; } else { - res = doAnalyserVariable(variable, mModel->states()); - - if (res == nullptr) { - res = doAnalyserVariable(variable, variables(mModel)); - } + res = doAnalyserVariable(variable, variables(mModel)); } return res; @@ -382,24 +378,8 @@ std::string Generator::GeneratorImpl::generateVariableInfoObjectCode(const std:: size_t nameSize = 0; size_t unitsSize = 0; - if (modelHasOdes()) { - updateVariableInfoSizes(componentSize, nameSize, unitsSize, mModel->voi()); - - for (const auto &state : mModel->states()) { - updateVariableInfoSizes(componentSize, nameSize, unitsSize, state); - } - } - - for (const auto &constant : mModel->constants()) { - updateVariableInfoSizes(componentSize, nameSize, unitsSize, constant); - } - - for (const auto &computedConstant : mModel->computedConstants()) { - updateVariableInfoSizes(componentSize, nameSize, unitsSize, computedConstant); - } - - for (const auto &algebraicVariable : mModel->algebraic()) { - updateVariableInfoSizes(componentSize, nameSize, unitsSize, algebraicVariable); + for (const auto &variable : variables(mModel)) { + updateVariableInfoSizes(componentSize, nameSize, unitsSize, variable); } return replace(replace(replace(objectString, @@ -536,20 +516,24 @@ void Generator::GeneratorImpl::addImplementationVariableInfoCode() variableType = mProfile->algebraicVariableTypeString(); break; - default: // AnalyserVariable::Type::EXTERNAL. + case AnalyserVariable::Type::EXTERNAL: variableType = mProfile->externalVariableTypeString(); + break; + default: // Other types we don't care about. break; } - auto variableVariable = variable->variable(); + if (!variableType.empty()) { + auto variableVariable = variable->variable(); - infoElementsCode += mProfile->indentString() - + replace(replace(replace(replace(mProfile->variableInfoEntryString(), - "[NAME]", variableVariable->name()), - "[UNITS]", variableVariable->units()->name()), - "[COMPONENT]", owningComponent(variableVariable)->name()), - "[TYPE]", variableType); + infoElementsCode += mProfile->indentString() + + replace(replace(replace(replace(mProfile->variableInfoEntryString(), + "[NAME]", variableVariable->name()), + "[UNITS]", variableVariable->units()->name()), + "[COMPONENT]", owningComponent(variableVariable)->name()), + "[TYPE]", variableType); + } } if (!infoElementsCode.empty()) { diff --git a/src/utilities.cpp b/src/utilities.cpp index 77815b38b..73473b673 100644 --- a/src/utilities.cpp +++ b/src/utilities.cpp @@ -1319,7 +1319,24 @@ XmlNodePtr mathmlChildNode(const XmlNodePtr &node, size_t index) std::vector variables(const AnalyserModelPtr &model) { - auto res = model->constants(); + std::vector res; + + if (model->voi() != nullptr) { + res.push_back(model->voi()); + } + + auto states = model->states(); + + if (!states.empty()) { + res.insert(res.end(), states.begin(), states.end()); + } + + auto constants = model->constants(); + + if (!constants.empty()) { + res.insert(res.end(), constants.begin(), constants.end()); + } + auto computedConstants = model->computedConstants(); if (!computedConstants.empty()) { @@ -1343,7 +1360,19 @@ std::vector variables(const AnalyserModelPtr &model) std::vector variables(const AnalyserEquationPtr &equation) { - auto res = equation->computedConstants(); + auto res = equation->states(); + auto constants = equation->constants(); + + if (!constants.empty()) { + res.insert(res.end(), constants.begin(), constants.end()); + } + + auto computedConstants = equation->computedConstants(); + + if (!computedConstants.empty()) { + res.insert(res.end(), computedConstants.begin(), computedConstants.end()); + } + auto algebraic = equation->algebraic(); if (!algebraic.empty()) { diff --git a/tests/bindings/javascript/analyserequation.test.js b/tests/bindings/javascript/analyserequation.test.js index b16f7def0..826926899 100644 --- a/tests/bindings/javascript/analyserequation.test.js +++ b/tests/bindings/javascript/analyserequation.test.js @@ -80,13 +80,13 @@ describe("Analyser Equation tests", () => { expect(eqn.computedConstant(0)).toBeNull() }); test('Checking Analyser Equation algebraicCount.', () => { - expect(eqn.algebraicCount()).toBe(1) + expect(eqn.algebraicCount()).toBe(0) }); test('Checking Analyser Equation algebraicVariables.', () => { - expect(eqn.algebraicVariables().size()).toBe(1) + expect(eqn.algebraicVariables().size()).toBe(0) }); test('Checking Analyser Equation algebraicVariable.', () => { - expect(eqn.algebraicVariable(0).variable().name()).toBe("x") + expect(eqn.algebraicVariable(0)).toBeNull() }); test('Checking Analyser Equation externalCount.', () => { expect(eqn.externalCount()).toBe(0) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index 7650d5f48..0c3b6b4a5 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -20,9 +20,9 @@ typedef enum { } VariableType; typedef struct { - char name[0]; - char units[0]; - char component[0]; + char name[2]; + char units[14]; + char component[20]; VariableType type; } VariableInfo; From 9f8bf25d0230edd357a0ff7ed79971f048769d10 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 12 Aug 2024 18:29:31 +0200 Subject: [PATCH 19/74] Generator: generate the CONSTANT_INFO, COMPUTED_CONSTANT_INFO, ALGEBRAIC_INFO, and EXTERNAL_INFO arrays rather than just the VARIABLE_INFO array. --- src/api/libcellml/generatorprofile.h | 190 ++++++++++++++++-- src/bindings/interface/generatorprofile.i | 58 +++++- src/bindings/javascript/generatorprofile.cpp | 20 +- src/generator.cpp | 157 ++++++--------- src/generator_p.h | 7 +- src/generatorprofile.cpp | 131 ++++++++++-- src/generatorprofilesha1values.h | 4 +- src/generatorprofiletools.cpp | 13 +- tests/bindings/javascript/generator.test.js | 4 +- .../javascript/generatorprofile.test.js | 48 ++++- .../bindings/python/test_generator_profile.py | 91 +++++++-- tests/coverage/coverage.cpp | 21 +- tests/generator/generatorprofile.cpp | 50 ++++- tests/resources/coverage/generator/model.c | 12 +- tests/resources/coverage/generator/model.h | 4 +- .../generator/model.modified.profile.c | 12 +- .../generator/model.modified.profile.h | 4 +- .../generator/model.modified.profile.py | 17 +- tests/resources/coverage/generator/model.py | 17 +- .../algebraic_eqn_computed_var_on_rhs/model.c | 8 +- .../model.external.c | 13 +- .../model.external.h | 5 +- .../model.external.py | 13 +- .../algebraic_eqn_computed_var_on_rhs/model.h | 4 +- .../model.py | 8 +- .../algebraic_eqn_const_var_on_rhs/model.c | 10 +- .../algebraic_eqn_const_var_on_rhs/model.h | 4 +- .../algebraic_eqn_const_var_on_rhs/model.py | 10 +- .../algebraic_eqn_constant_on_rhs/model.c | 8 +- .../algebraic_eqn_constant_on_rhs/model.h | 4 +- .../algebraic_eqn_constant_on_rhs/model.py | 8 +- .../algebraic_eqn_derivative_on_rhs/model.c | 10 +- .../algebraic_eqn_derivative_on_rhs/model.h | 4 +- .../algebraic_eqn_derivative_on_rhs/model.py | 13 +- .../model.c | 10 +- .../model.h | 4 +- .../model.py | 13 +- .../algebraic_eqn_state_var_on_rhs/model.c | 10 +- .../algebraic_eqn_state_var_on_rhs/model.h | 4 +- .../algebraic_eqn_state_var_on_rhs/model.py | 13 +- .../model.c | 10 +- .../model.h | 4 +- .../model.py | 13 +- .../model.c | 10 +- .../model.external.c | 13 +- .../model.external.h | 5 +- .../model.external.py | 13 +- .../model.h | 4 +- .../model.py | 10 +- .../model.c | 8 +- .../model.h | 4 +- .../model.py | 8 +- .../model.three.externals.c | 11 +- .../model.three.externals.h | 5 +- .../model.three.externals.py | 11 +- .../model.not.ordered.c | 12 +- .../model.not.ordered.h | 4 +- .../model.not.ordered.py | 12 +- .../model.ordered.c | 12 +- .../model.ordered.h | 4 +- .../model.ordered.py | 12 +- .../algebraic_unknown_var_on_rhs/model.c | 8 +- .../algebraic_unknown_var_on_rhs/model.h | 4 +- .../algebraic_unknown_var_on_rhs/model.py | 8 +- .../generator/cell_geometry_model/model.c | 10 +- .../cell_geometry_model/model.external.c | 13 +- .../cell_geometry_model/model.external.h | 5 +- .../cell_geometry_model/model.external.py | 13 +- .../generator/cell_geometry_model/model.h | 4 +- .../generator/cell_geometry_model/model.py | 10 +- .../model.c | 8 +- .../model.h | 4 +- .../model.py | 11 +- .../generator/cellml_slc_example/model.py | 10 +- .../model.c | 8 +- .../model.h | 4 +- .../model.py | 13 +- .../cellml_unit_scaling_constant/model.c | 10 +- .../cellml_unit_scaling_constant/model.h | 4 +- .../cellml_unit_scaling_constant/model.py | 10 +- .../cellml_unit_scaling_rate/model.c | 8 +- .../cellml_unit_scaling_rate/model.h | 4 +- .../cellml_unit_scaling_rate/model.py | 11 +- .../cellml_unit_scaling_state/model.c | 8 +- .../cellml_unit_scaling_state/model.h | 4 +- .../cellml_unit_scaling_state/model.py | 11 +- .../model.c | 8 +- .../model.h | 4 +- .../model.py | 11 +- .../model.c | 8 +- .../model.h | 4 +- .../model.py | 13 +- .../cellml_unit_scaling_voi_direct/model.c | 8 +- .../cellml_unit_scaling_voi_direct/model.h | 4 +- .../cellml_unit_scaling_voi_direct/model.py | 11 +- .../cellml_unit_scaling_voi_indirect/model.c | 8 +- .../cellml_unit_scaling_voi_indirect/model.h | 4 +- .../cellml_unit_scaling_voi_indirect/model.py | 11 +- .../generator/dae_cellml_1_1_model/model.c | 10 +- .../generator/dae_cellml_1_1_model/model.h | 4 +- .../generator/dae_cellml_1_1_model/model.py | 15 +- .../generator/dependent_eqns/model.c | 8 +- .../generator/dependent_eqns/model.h | 4 +- .../generator/dependent_eqns/model.py | 11 +- .../model.c | 12 +- .../model.h | 4 +- .../model.py | 17 +- .../model.c | 12 +- .../model.h | 4 +- .../model.py | 17 +- .../model.algebraic.c | 17 +- .../model.algebraic.h | 5 +- .../model.algebraic.py | 22 +- .../model.c | 12 +- .../model.computed.constant.c | 17 +- .../model.computed.constant.h | 5 +- .../model.computed.constant.py | 22 +- .../model.constant.c | 17 +- .../model.constant.h | 5 +- .../model.constant.py | 22 +- .../model.dae.c | 12 +- .../model.dae.h | 4 +- .../model.dae.py | 17 +- .../model.dependent.algebraic.c | 17 +- .../model.dependent.algebraic.h | 5 +- .../model.dependent.algebraic.py | 22 +- .../model.dependent.computed.constant.c | 15 +- .../model.dependent.computed.constant.h | 5 +- .../model.dependent.computed.constant.py | 20 +- .../model.dependent.constant.c | 17 +- .../model.dependent.constant.h | 5 +- .../model.dependent.constant.py | 22 +- .../model.dependent.state.c | 17 +- .../model.dependent.state.h | 5 +- .../model.dependent.state.py | 22 +- .../model.external.c | 17 +- .../model.external.h | 5 +- .../model.external.py | 22 +- .../model.h | 4 +- .../model.py | 17 +- .../model.state.c | 17 +- .../model.state.h | 5 +- .../model.state.py | 22 +- .../generator/noble_model_1962/model.c | 10 +- .../generator/noble_model_1962/model.h | 4 +- .../generator/noble_model_1962/model.py | 15 +- .../generator/ode_computed_var_on_rhs/model.c | 8 +- .../generator/ode_computed_var_on_rhs/model.h | 4 +- .../ode_computed_var_on_rhs/model.py | 11 +- .../model.c | 8 +- .../model.h | 4 +- .../model.py | 11 +- .../generator/ode_const_var_on_rhs/model.c | 8 +- .../generator/ode_const_var_on_rhs/model.h | 4 +- .../generator/ode_const_var_on_rhs/model.py | 13 +- .../model.c | 8 +- .../model.h | 4 +- .../model.py | 13 +- .../generator/ode_constant_on_rhs/model.c | 8 +- .../generator/ode_constant_on_rhs/model.h | 4 +- .../generator/ode_constant_on_rhs/model.py | 11 +- .../ode_constant_on_rhs_one_component/model.c | 8 +- .../ode_constant_on_rhs_one_component/model.h | 4 +- .../model.py | 11 +- .../ode_multiple_dependent_odes/model.c | 8 +- .../ode_multiple_dependent_odes/model.h | 4 +- .../ode_multiple_dependent_odes/model.py | 13 +- .../model.c | 8 +- .../model.h | 4 +- .../model.py | 13 +- .../ode_multiple_odes_with_same_name/model.c | 8 +- .../ode_multiple_odes_with_same_name/model.h | 4 +- .../ode_multiple_odes_with_same_name/model.py | 13 +- .../generator/ode_unknown_var_on_rhs/model.c | 8 +- .../generator/ode_unknown_var_on_rhs/model.h | 4 +- .../generator/ode_unknown_var_on_rhs/model.py | 11 +- .../robertson_model_1966/model.dae.c | 10 +- .../robertson_model_1966/model.dae.h | 4 +- .../robertson_model_1966/model.dae.py | 15 +- .../robertson_model_1966/model.ode.c | 10 +- .../robertson_model_1966/model.ode.h | 4 +- .../robertson_model_1966/model.ode.py | 15 +- .../generator/sine_model_imports/model.c | 12 +- .../generator/sine_model_imports/model.h | 4 +- .../generator/sine_model_imports/model.py | 17 +- .../model.c | 15 +- .../model.h | 5 +- .../model.py | 15 +- .../model.c | 8 +- .../model.h | 4 +- .../model.py | 13 +- 191 files changed, 1908 insertions(+), 606 deletions(-) diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index 4cefa11f2..b3ee8ec27 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -2948,53 +2948,203 @@ class LIBCELLML_EXPORT GeneratorProfile /** * @brief Get the @c std::string for the interface of some information about - * the different variables. + * the different constants. * * Return the @c std::string for the interface of some information about the - * different variables. + * different constants. * * @return The @c std::string for the interface of some information about - * the different variables. + * the different constants. */ - std::string interfaceVariableInfoString() const; + std::string interfaceConstantInfoString() const; /** * @brief Set the @c std::string for the interface of some information about - * the different variables. + * the different constants. * * Set the @c std::string for the interface of some information about the - * different variables. + * different constants. * - * @param interfaceVariableInfoString The @c std::string to use for the - * interface of some information about the different variables. + * @param interfaceConstantInfoString The @c std::string to use for the + * interface of some information about the different constants. */ - void setInterfaceVariableInfoString(const std::string &interfaceVariableInfoString); + void setInterfaceConstantInfoString(const std::string &interfaceConstantInfoString); /** * @brief Get the @c std::string for the implementation of some information - * about the different variables. + * about the different constants. * * Return the @c std::string for the implementation of some information - * about the different variables. + * about the different constants. * * @return The @c std::string for the implementation of some information - * about the different variables. + * about the different constants. */ - std::string implementationVariableInfoString() const; + std::string implementationConstantInfoString() const; /** * @brief Set the @c std::string for the implementation of some information - * about the different variables. + * about the different constants. * * Set the @c std::string for the implementation of some information about - * the different variables. To be useful, the string should contain the - * [CODE] tag, which will be replaced with some information about the - * different variables. + * the different constants. To be useful, the string should contain the [CODE] + * tag, which will be replaced with some information about the different + * constants. + * + * @param implementationConstantInfoString The @c std::string to use for the + * implementation of some information about the different constants. + */ + void setImplementationConstantInfoString(const std::string &implementationConstantInfoString); + + /** + * @brief Get the @c std::string for the interface of some information about + * the different computed constants. + * + * Return the @c std::string for the interface of some information about the + * different computed constants. + * + * @return The @c std::string for the interface of some information about + * the different computed constants. + */ + std::string interfaceComputedConstantInfoString() const; + + /** + * @brief Set the @c std::string for the interface of some information about + * the different computed constants. + * + * Set the @c std::string for the interface of some information about the + * different computed constants. + * + * @param interfaceComputedConstantInfoString The @c std::string to use for the + * interface of some information about the different computed constants. + */ + void setInterfaceComputedConstantInfoString(const std::string &interfaceComputedConstantInfoString); + + /** + * @brief Get the @c std::string for the implementation of some information + * about the different computed constants. + * + * Return the @c std::string for the implementation of some information + * about the different computed constants. + * + * @return The @c std::string for the implementation of some information + * about the different computed constants. + */ + std::string implementationComputedConstantInfoString() const; + + /** + * @brief Set the @c std::string for the implementation of some information + * about the different computed constants. + * + * Set the @c std::string for the implementation of some information about + * the different computed constants. To be useful, the string should contain the [CODE] + * tag, which will be replaced with some information about the different + * computed constants. + * + * @param implementationComputedConstantInfoString The @c std::string to use for the + * implementation of some information about the different computed constants. + */ + void setImplementationComputedConstantInfoString(const std::string &implementationComputedConstantInfoString); + + /** + * @brief Get the @c std::string for the interface of some information about + * the different algebraic variables. + * + * Return the @c std::string for the interface of some information about the + * different algebraic variables. + * + * @return The @c std::string for the interface of some information about + * the different algebraic variables. + */ + std::string interfaceAlgebraicInfoString() const; + + /** + * @brief Set the @c std::string for the interface of some information about + * the different algebraic variables. + * + * Set the @c std::string for the interface of some information about the + * different algebraic variables. + * + * @param interfaceAlgebraicInfoString The @c std::string to use for the + * interface of some information about the different algebraic variables. + */ + void setInterfaceAlgebraicInfoString(const std::string &interfaceAlgebraicInfoString); + + /** + * @brief Get the @c std::string for the implementation of some information + * about the different algebraic variables. + * + * Return the @c std::string for the implementation of some information + * about the different algebraic variables. + * + * @return The @c std::string for the implementation of some information + * about the different algebraic variables. + */ + std::string implementationAlgebraicInfoString() const; + + /** + * @brief Set the @c std::string for the implementation of some information + * about the different algebraic variables. + * + * Set the @c std::string for the implementation of some information about + * the different algebraic variables. To be useful, the string should contain the [CODE] + * tag, which will be replaced with some information about the different + * algebraic variables. + * + * @param implementationAlgebraicInfoString The @c std::string to use for the + * implementation of some information about the different algebraic variables. + */ + void setImplementationAlgebraicInfoString(const std::string &implementationAlgebraicInfoString); + + /** + * @brief Get the @c std::string for the interface of some information about + * the different external variables. + * + * Return the @c std::string for the interface of some information about the + * different external variables. + * + * @return The @c std::string for the interface of some information about + * the different external variables. + */ + std::string interfaceExternalInfoString() const; + + /** + * @brief Set the @c std::string for the interface of some information about + * the different external variables. + * + * Set the @c std::string for the interface of some information about the + * different external variables. + * + * @param interfaceExternalInfoString The @c std::string to use for the + * interface of some information about the different external variables. + */ + void setInterfaceExternalInfoString(const std::string &interfaceExternalInfoString); + + /** + * @brief Get the @c std::string for the implementation of some information + * about the different external variables. + * + * Return the @c std::string for the implementation of some information + * about the different external variables. + * + * @return The @c std::string for the implementation of some information + * about the different external variables. + */ + std::string implementationExternalInfoString() const; + + /** + * @brief Set the @c std::string for the implementation of some information + * about the different external variables. + * + * Set the @c std::string for the implementation of some information about + * the different external variables. To be useful, the string should contain the [CODE] + * tag, which will be replaced with some information about the different + * external variables. * - * @param implementationVariableInfoString The @c std::string to use for the - * implementation of some information about the different variables. + * @param implementationExternalInfoString The @c std::string to use for the + * implementation of some information about the different external variables. */ - void setImplementationVariableInfoString(const std::string &implementationVariableInfoString); + void setImplementationExternalInfoString(const std::string &implementationExternalInfoString); /** * @brief Get the @c std::string for an entry in an array for some diff --git a/src/bindings/interface/generatorprofile.i b/src/bindings/interface/generatorprofile.i index 51e227c13..b7e5c3cb6 100644 --- a/src/bindings/interface/generatorprofile.i +++ b/src/bindings/interface/generatorprofile.i @@ -806,19 +806,57 @@ integration."; "Sets the string for the implementation of some information about the different states. To be useful, the string should contain the tag, which will be replaced with some information about the different states."; -%feature("docstring") libcellml::GeneratorProfile::interfaceVariableInfoString -"Returns the string for the interface of some information about the different variables."; +%feature("docstring") libcellml::GeneratorProfile::interfaceConstantInfoString +"Returns the string for the interface of some information about the different constants."; -%feature("docstring") libcellml::GeneratorProfile::setInterfaceVariableInfoString -"Sets the string for the interface of some information about the different variables."; +%feature("docstring") libcellml::GeneratorProfile::setInterfaceConstantInfoString +"Sets the string for the interface of some information about the different constants."; -%feature("docstring") libcellml::GeneratorProfile::implementationVariableInfoString -"Returns the string for the implementation of some information about the different variables."; +%feature("docstring") libcellml::GeneratorProfile::implementationConstantInfoString +"Returns the string for the implementation of some information about the different constants."; -%feature("docstring") libcellml::GeneratorProfile::setImplementationVariableInfoString -"Sets the string for the implementation of some information about the different variables. To be useful, the -string should contain the tag, which will be replaced with some information about the different -variables."; +%feature("docstring") libcellml::GeneratorProfile::setImplementationConstantInfoString +"Sets the string for the implementation of some information about the different constants. To be useful, the string +should contain the tag, which will be replaced with some information about the different constants."; + +%feature("docstring") libcellml::GeneratorProfile::interfaceComputedConstantInfoString +"Returns the string for the interface of some information about the different computed constants."; + +%feature("docstring") libcellml::GeneratorProfile::setInterfaceComputedConstantInfoString +"Sets the string for the interface of some information about the different computed constants."; + +%feature("docstring") libcellml::GeneratorProfile::implementationComputedConstantInfoString +"Returns the string for the implementation of some information about the different computed constants."; + +%feature("docstring") libcellml::GeneratorProfile::setImplementationComputedConstantInfoString +"Sets the string for the implementation of some information about the different computed constants. To be useful, the string +should contain the tag, which will be replaced with some information about the different computed constants."; + +%feature("docstring") libcellml::GeneratorProfile::interfaceAlgebraicInfoString +"Returns the string for the interface of some information about the different algebraic variables."; + +%feature("docstring") libcellml::GeneratorProfile::setInterfaceAlgebraicInfoString +"Sets the string for the interface of some information about the different algebraic variables."; + +%feature("docstring") libcellml::GeneratorProfile::implementationAlgebraicInfoString +"Returns the string for the implementation of some information about the different algebraic variables."; + +%feature("docstring") libcellml::GeneratorProfile::setImplementationAlgebraicInfoString +"Sets the string for the implementation of some information about the different algebraic variables. To be useful, the string +should contain the tag, which will be replaced with some information about the different algebraic variables."; + +%feature("docstring") libcellml::GeneratorProfile::interfaceExternalInfoString +"Returns the string for the interface of some information about the different external variables."; + +%feature("docstring") libcellml::GeneratorProfile::setInterfaceExternalInfoString +"Sets the string for the interface of some information about the different external variables."; + +%feature("docstring") libcellml::GeneratorProfile::implementationExternalInfoString +"Returns the string for the implementation of some information about the different external variables."; + +%feature("docstring") libcellml::GeneratorProfile::setImplementationExternalInfoString +"Sets the string for the implementation of some information about the different external variables. To be useful, the string +should contain the tag, which will be replaced with some information about the different external variables."; %feature("docstring") libcellml::GeneratorProfile::variableInfoEntryString "Returns the string for an entry in an array for some information about a variable."; diff --git a/src/bindings/javascript/generatorprofile.cpp b/src/bindings/javascript/generatorprofile.cpp index 8bb3e36c1..b2fef805b 100644 --- a/src/bindings/javascript/generatorprofile.cpp +++ b/src/bindings/javascript/generatorprofile.cpp @@ -291,10 +291,22 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setInterfaceStateInfoString", &libcellml::GeneratorProfile::setInterfaceStateInfoString) .function("implementationStateInfoString", &libcellml::GeneratorProfile::implementationStateInfoString) .function("setImplementationStateInfoString", &libcellml::GeneratorProfile::setImplementationStateInfoString) - .function("interfaceVariableInfoString", &libcellml::GeneratorProfile::interfaceVariableInfoString) - .function("setInterfaceVariableInfoString", &libcellml::GeneratorProfile::setInterfaceVariableInfoString) - .function("implementationVariableInfoString", &libcellml::GeneratorProfile::implementationVariableInfoString) - .function("setImplementationVariableInfoString", &libcellml::GeneratorProfile::setImplementationVariableInfoString) + .function("interfaceConstantInfoString", &libcellml::GeneratorProfile::interfaceConstantInfoString) + .function("setInterfaceConstantInfoString", &libcellml::GeneratorProfile::setInterfaceConstantInfoString) + .function("implementationConstantInfoString", &libcellml::GeneratorProfile::implementationConstantInfoString) + .function("setImplementationConstantInfoString", &libcellml::GeneratorProfile::setImplementationConstantInfoString) + .function("interfaceComputedConstantInfoString", &libcellml::GeneratorProfile::interfaceComputedConstantInfoString) + .function("setInterfaceComputedConstantInfoString", &libcellml::GeneratorProfile::setInterfaceComputedConstantInfoString) + .function("implementationComputedConstantInfoString", &libcellml::GeneratorProfile::implementationComputedConstantInfoString) + .function("setImplementationComputedConstantInfoString", &libcellml::GeneratorProfile::setImplementationComputedConstantInfoString) + .function("interfaceAlgebraicInfoString", &libcellml::GeneratorProfile::interfaceAlgebraicInfoString) + .function("setInterfaceAlgebraicInfoString", &libcellml::GeneratorProfile::setInterfaceAlgebraicInfoString) + .function("implementationAlgebraicInfoString", &libcellml::GeneratorProfile::implementationAlgebraicInfoString) + .function("setImplementationAlgebraicInfoString", &libcellml::GeneratorProfile::setImplementationAlgebraicInfoString) + .function("interfaceExternalInfoString", &libcellml::GeneratorProfile::interfaceExternalInfoString) + .function("setInterfaceExternalInfoString", &libcellml::GeneratorProfile::setInterfaceExternalInfoString) + .function("implementationExternalInfoString", &libcellml::GeneratorProfile::implementationExternalInfoString) + .function("setImplementationExternalInfoString", &libcellml::GeneratorProfile::setImplementationExternalInfoString) .function("variableInfoEntryString", &libcellml::GeneratorProfile::variableInfoEntryString) .function("setVariableInfoEntryString", &libcellml::GeneratorProfile::setVariableInfoEntryString) .function("voiString", &libcellml::GeneratorProfile::voiString) diff --git a/src/generator.cpp b/src/generator.cpp index 4a280ce43..442fc9d1a 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -408,7 +408,7 @@ std::string Generator::GeneratorImpl::generateVariableInfoEntryCode(const std::s "[TYPE]", type); } -void Generator::GeneratorImpl::addInterfaceVoiStateAndVariableInfoCode() +void Generator::GeneratorImpl::addInterfaceVariableInfoCode() { std::string code; @@ -422,127 +422,98 @@ void Generator::GeneratorImpl::addInterfaceVoiStateAndVariableInfoCode() code += mProfile->interfaceStateInfoString(); } - if (!mProfile->interfaceVariableInfoString().empty()) { - code += mProfile->interfaceVariableInfoString(); + if (!mProfile->interfaceConstantInfoString().empty()) { + code += mProfile->interfaceConstantInfoString(); } - if (!code.empty()) { - mCode += "\n"; + if (!mProfile->interfaceComputedConstantInfoString().empty()) { + code += mProfile->interfaceComputedConstantInfoString(); } - mCode += code; -} + if (!mProfile->interfaceAlgebraicInfoString().empty()) { + code += mProfile->interfaceAlgebraicInfoString(); + } -void Generator::GeneratorImpl::addImplementationVoiInfoCode() -{ - if (modelHasOdes() - && !mProfile->implementationVoiInfoString().empty() - && !mProfile->variableInfoEntryString().empty() - && !mProfile->variableOfIntegrationVariableTypeString().empty()) { - auto voiVariable = mModel->voi()->variable(); - auto name = voiVariable->name(); - auto units = voiVariable->units()->name(); - auto component = owningComponent(voiVariable)->name(); - auto type = mProfile->variableOfIntegrationVariableTypeString(); + if (mModel->hasExternalVariables() + && !mProfile->interfaceExternalInfoString().empty()) { + code += mProfile->interfaceExternalInfoString(); + } - mCode += newLineIfNeeded() - + replace(mProfile->implementationVoiInfoString(), - "[CODE]", generateVariableInfoEntryCode(name, units, component, type)); + if (!code.empty()) { + mCode += "\n"; } + + mCode += code; } -void Generator::GeneratorImpl::addImplementationStateInfoCode() +void Generator::GeneratorImpl::doAddImplementationVariableInfoCode(const std::string &variableInfoString, + const std::string &variableTypeString, + const std::vector &variables, + bool voiVariable) { - if (modelHasOdes() - && !mProfile->implementationStateInfoString().empty() + if (!variableInfoString.empty() && !mProfile->variableInfoEntryString().empty() - && !mProfile->stateVariableTypeString().empty() + && !variableTypeString.empty() && !mProfile->arrayElementSeparatorString().empty()) { std::string infoElementsCode; - auto type = mProfile->stateVariableTypeString(); - for (const auto &state : mModel->states()) { + for (const auto &variable : variables) { if (!infoElementsCode.empty()) { infoElementsCode += mProfile->arrayElementSeparatorString() + "\n"; } - auto stateVariable = state->variable(); + auto variableVariable = variable->variable(); - infoElementsCode += mProfile->indentString() - + generateVariableInfoEntryCode(stateVariable->name(), - stateVariable->units()->name(), - owningComponent(stateVariable)->name(), - type); + infoElementsCode += (voiVariable ? "" : mProfile->indentString()) + + generateVariableInfoEntryCode(variableVariable->name(), + variableVariable->units()->name(), + owningComponent(variableVariable)->name(), + variableTypeString); } - infoElementsCode += "\n"; + if (!voiVariable && !infoElementsCode.empty()) { + infoElementsCode += "\n"; + } mCode += newLineIfNeeded() - + replace(mProfile->implementationStateInfoString(), - "[CODE]", infoElementsCode); + + replace(variableInfoString, "[CODE]", infoElementsCode); } } void Generator::GeneratorImpl::addImplementationVariableInfoCode() { - if (!mProfile->implementationVariableInfoString().empty() - && !mProfile->variableInfoEntryString().empty() - && !mProfile->arrayElementSeparatorString().empty() - && !mProfile->variableOfIntegrationVariableTypeString().empty() - && !mProfile->stateVariableTypeString().empty() - && !mProfile->constantVariableTypeString().empty() - && !mProfile->computedConstantVariableTypeString().empty() - && !mProfile->algebraicVariableTypeString().empty() - && !mProfile->externalVariableTypeString().empty()) { - std::string infoElementsCode; + if (modelHasOdes()) { + std::vector variables; - for (const auto &variable : variables(mModel)) { - if (!infoElementsCode.empty()) { - infoElementsCode += mProfile->arrayElementSeparatorString() + "\n"; - } + variables.push_back(mModel->voi()); - std::string variableType; - - switch (variable->type()) { - case AnalyserVariable::Type::CONSTANT: - variableType = mProfile->constantVariableTypeString(); - - break; - case AnalyserVariable::Type::COMPUTED_CONSTANT: - variableType = mProfile->computedConstantVariableTypeString(); - - break; - case AnalyserVariable::Type::ALGEBRAIC: - variableType = mProfile->algebraicVariableTypeString(); - - break; - case AnalyserVariable::Type::EXTERNAL: - variableType = mProfile->externalVariableTypeString(); + doAddImplementationVariableInfoCode(mProfile->implementationVoiInfoString(), + mProfile->variableOfIntegrationVariableTypeString(), + variables, true); + } - break; - default: // Other types we don't care about. - break; - } + if (modelHasOdes()) { + doAddImplementationVariableInfoCode(mProfile->implementationStateInfoString(), + mProfile->stateVariableTypeString(), + mModel->states(), false); + } - if (!variableType.empty()) { - auto variableVariable = variable->variable(); + doAddImplementationVariableInfoCode(mProfile->implementationConstantInfoString(), + mProfile->constantVariableTypeString(), + mModel->constants(), false); - infoElementsCode += mProfile->indentString() - + replace(replace(replace(replace(mProfile->variableInfoEntryString(), - "[NAME]", variableVariable->name()), - "[UNITS]", variableVariable->units()->name()), - "[COMPONENT]", owningComponent(variableVariable)->name()), - "[TYPE]", variableType); - } - } + doAddImplementationVariableInfoCode(mProfile->implementationComputedConstantInfoString(), + mProfile->computedConstantVariableTypeString(), + mModel->computedConstants(), false); - if (!infoElementsCode.empty()) { - infoElementsCode += "\n"; - } + doAddImplementationVariableInfoCode(mProfile->implementationAlgebraicInfoString(), + mProfile->algebraicVariableTypeString(), + mModel->algebraic(), false); - mCode += newLineIfNeeded() - + replace(mProfile->implementationVariableInfoString(), - "[CODE]", infoElementsCode); + if (mModel->hasExternalVariables()) { + doAddImplementationVariableInfoCode(mProfile->implementationExternalInfoString(), + mProfile->externalVariableTypeString(), + mModel->externals(), false); } } @@ -2057,10 +2028,10 @@ std::string Generator::interfaceCode() const mPimpl->addVariableTypeObjectCode(); mPimpl->addVariableInfoObjectCode(); - // Add code for the interface of the information about the variable of - // integration, states and (other) variables. + // Add code for the interface of the information about the variable of integration, states, constants, computed + // constants, algebraic variables, and external variables. - mPimpl->addInterfaceVoiStateAndVariableInfoCode(); + mPimpl->addInterfaceVariableInfoCode(); // Add code for the interface to create and delete arrays. @@ -2113,11 +2084,9 @@ std::string Generator::implementationCode() const mPimpl->addVariableInfoObjectCode(); } - // Add code for the implementation of the information about the variable of - // integration, states and (other) variables. + // Add code for the implementation of the information about the variable of integration, states, constants, computed + // constants, algebraic variables, and external variables. - mPimpl->addImplementationVoiInfoCode(); - mPimpl->addImplementationStateInfoCode(); mPimpl->addImplementationVariableInfoCode(); // Add code for the arithmetic and trigonometric functions. diff --git a/src/generator_p.h b/src/generator_p.h index 4f9165da5..fd79ffbff 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -93,9 +93,10 @@ struct Generator::GeneratorImpl const std::string &component, const std::string &type) const; - void addInterfaceVoiStateAndVariableInfoCode(); - void addImplementationVoiInfoCode(); - void addImplementationStateInfoCode(); + void addInterfaceVariableInfoCode(); + + void doAddImplementationVariableInfoCode(const std::string &variableInfoString, const std::string &variableTypeString, + const std::vector &variables, bool voiVariable); void addImplementationVariableInfoCode(); void addArithmeticFunctionsCode(); diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index ca8c24d90..4258948d4 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -216,8 +216,17 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mInterfaceStateInfoString; std::string mImplementationStateInfoString; - std::string mInterfaceVariableInfoString; - std::string mImplementationVariableInfoString; + std::string mInterfaceConstantInfoString; + std::string mImplementationConstantInfoString; + + std::string mInterfaceComputedConstantInfoString; + std::string mImplementationComputedConstantInfoString; + + std::string mInterfaceAlgebraicInfoString; + std::string mImplementationAlgebraicInfoString; + + std::string mInterfaceExternalInfoString; + std::string mImplementationExternalInfoString; std::string mVariableInfoEntryString; @@ -577,8 +586,23 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "};\n"; - mInterfaceVariableInfoString = "extern const VariableInfo VARIABLE_INFO[];\n"; - mImplementationVariableInfoString = "const VariableInfo VARIABLE_INFO[] = {\n" + mInterfaceConstantInfoString = "extern const VariableInfo CONSTANT_INFO[];\n"; + mImplementationConstantInfoString = "const VariableInfo CONSTANT_INFO[] = {\n" + "[CODE]" + "};\n"; + + mInterfaceComputedConstantInfoString = "extern const VariableInfo COMPUTED_CONSTANT_INFO[];\n"; + mImplementationComputedConstantInfoString = "const VariableInfo COMPUTED_CONSTANT_INFO[] = {\n" + "[CODE]" + "};\n"; + + mInterfaceAlgebraicInfoString = "extern const VariableInfo ALGEBRAIC_INFO[];\n"; + mImplementationAlgebraicInfoString = "const VariableInfo ALGEBRAIC_INFO[] = {\n" + "[CODE]" + "};\n"; + + mInterfaceExternalInfoString = "extern const VariableInfo EXTERNAL_INFO[];\n"; + mImplementationExternalInfoString = "const VariableInfo EXTERNAL_INFO[] = {\n" "[CODE]" "};\n"; @@ -1012,12 +1036,25 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mImplementationVoiInfoString = "VOI_INFO = [CODE]\n"; mInterfaceStateInfoString = ""; - mImplementationStateInfoString = "STATE_INFO = [\n" - "[CODE]" - "]\n"; + mImplementationStateInfoString = "STATE_INFO = [CODE]\n"; - mInterfaceVariableInfoString = ""; - mImplementationVariableInfoString = "VARIABLE_INFO = [\n" + mInterfaceConstantInfoString = ""; + mImplementationConstantInfoString = "CONSTANT_INFO = [\n" + "[CODE]" + "]\n"; + + mInterfaceComputedConstantInfoString = ""; + mImplementationComputedConstantInfoString = "COMPUTED_CONSTANT_INFO = [\n" + "[CODE]" + "]\n"; + + mInterfaceAlgebraicInfoString = ""; + mImplementationAlgebraicInfoString = "ALGEBRAIC_INFO = [\n" + "[CODE]" + "]\n"; + + mInterfaceExternalInfoString = ""; + mImplementationExternalInfoString = "EXTERNAL_INFO = [\n" "[CODE]" "]\n"; @@ -2510,24 +2547,84 @@ void GeneratorProfile::setImplementationStateInfoString(const std::string &imple mPimpl->mImplementationStateInfoString = implementationStateInfoString; } -std::string GeneratorProfile::interfaceVariableInfoString() const +std::string GeneratorProfile::interfaceConstantInfoString() const +{ + return mPimpl->mInterfaceConstantInfoString; +} + +void GeneratorProfile::setInterfaceConstantInfoString(const std::string &interfaceConstantInfoString) +{ + mPimpl->mInterfaceConstantInfoString = interfaceConstantInfoString; +} + +std::string GeneratorProfile::implementationConstantInfoString() const +{ + return mPimpl->mImplementationConstantInfoString; +} + +void GeneratorProfile::setImplementationConstantInfoString(const std::string &implementationConstantInfoString) +{ + mPimpl->mImplementationConstantInfoString = implementationConstantInfoString; +} + +std::string GeneratorProfile::interfaceComputedConstantInfoString() const +{ + return mPimpl->mInterfaceComputedConstantInfoString; +} + +void GeneratorProfile::setInterfaceComputedConstantInfoString(const std::string &interfaceComputedConstantInfoString) +{ + mPimpl->mInterfaceComputedConstantInfoString = interfaceComputedConstantInfoString; +} + +std::string GeneratorProfile::implementationComputedConstantInfoString() const +{ + return mPimpl->mImplementationComputedConstantInfoString; +} + +void GeneratorProfile::setImplementationComputedConstantInfoString(const std::string &implementationComputedConstantInfoString) +{ + mPimpl->mImplementationComputedConstantInfoString = implementationComputedConstantInfoString; +} + +std::string GeneratorProfile::interfaceAlgebraicInfoString() const +{ + return mPimpl->mInterfaceAlgebraicInfoString; +} + +void GeneratorProfile::setInterfaceAlgebraicInfoString(const std::string &interfaceAlgebraicInfoString) +{ + mPimpl->mInterfaceAlgebraicInfoString = interfaceAlgebraicInfoString; +} + +std::string GeneratorProfile::implementationAlgebraicInfoString() const +{ + return mPimpl->mImplementationAlgebraicInfoString; +} + +void GeneratorProfile::setImplementationAlgebraicInfoString(const std::string &implementationAlgebraicInfoString) +{ + mPimpl->mImplementationAlgebraicInfoString = implementationAlgebraicInfoString; +} + +std::string GeneratorProfile::interfaceExternalInfoString() const { - return mPimpl->mInterfaceVariableInfoString; + return mPimpl->mInterfaceExternalInfoString; } -void GeneratorProfile::setInterfaceVariableInfoString(const std::string &interfaceVariableInfoString) +void GeneratorProfile::setInterfaceExternalInfoString(const std::string &interfaceExternalInfoString) { - mPimpl->mInterfaceVariableInfoString = interfaceVariableInfoString; + mPimpl->mInterfaceExternalInfoString = interfaceExternalInfoString; } -std::string GeneratorProfile::implementationVariableInfoString() const +std::string GeneratorProfile::implementationExternalInfoString() const { - return mPimpl->mImplementationVariableInfoString; + return mPimpl->mImplementationExternalInfoString; } -void GeneratorProfile::setImplementationVariableInfoString(const std::string &implementationVariableInfoString) +void GeneratorProfile::setImplementationExternalInfoString(const std::string &implementationExternalInfoString) { - mPimpl->mImplementationVariableInfoString = implementationVariableInfoString; + mPimpl->mImplementationExternalInfoString = implementationExternalInfoString; } std::string GeneratorProfile::variableInfoEntryString() const diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 17c92162a..5db086202 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "d81a3e718069fa9628dccbda291fb3cf017a4cee"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "b23d6ef4b54a76f94812b78da59c2bae319bdf8d"; +static const char C_GENERATOR_PROFILE_SHA1[] = "51c71d6a06d1b6e38467cc3f333062d5be98fba1"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "710333a658fecca12a9ff0c6bf41dd45a12c0f35"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index 3410a8102..f798af19d 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -474,8 +474,17 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->interfaceStateInfoString() + generatorProfile->implementationStateInfoString(); - profileContents += generatorProfile->interfaceVariableInfoString() - + generatorProfile->implementationVariableInfoString(); + profileContents += generatorProfile->interfaceConstantInfoString() + + generatorProfile->implementationConstantInfoString(); + + profileContents += generatorProfile->interfaceComputedConstantInfoString() + + generatorProfile->implementationComputedConstantInfoString(); + + profileContents += generatorProfile->interfaceAlgebraicInfoString() + + generatorProfile->implementationAlgebraicInfoString(); + + profileContents += generatorProfile->interfaceExternalInfoString() + + generatorProfile->implementationExternalInfoString(); profileContents += generatorProfile->variableInfoEntryString(); diff --git a/tests/bindings/javascript/generator.test.js b/tests/bindings/javascript/generator.test.js index bd854e65f..112ca913e 100644 --- a/tests/bindings/javascript/generator.test.js +++ b/tests/bindings/javascript/generator.test.js @@ -62,10 +62,10 @@ describe("Generator tests", () => { g.setModel(a.model()) const interface_lines = g.interfaceCode().split('\n') - expect(interface_lines.length).toBe(42) + expect(interface_lines.length).toBe(44) const implementation_lines = g.implementationCode().split('\n') - expect(implementation_lines.length).toBe(69) + expect(implementation_lines.length).toBe(66) const equation_line_1 = libcellml.Generator.equationCode(a.model().equation(0).ast()) expect(equation_line_1.length).toBe(14) diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index aa00a0e37..095d28052 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -810,17 +810,53 @@ describe("GeneratorProfile tests", () => { x.setImplementationStateInfoString("something") expect(x.implementationStateInfoString()).toBe("something") }); - test("Checking GeneratorProfile.interfaceVariableInfoString.", () => { + test("Checking GeneratorProfile.interfaceConstantInfoString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceVariableInfoString("something") - expect(x.interfaceVariableInfoString()).toBe("something") + x.setInterfaceConstantInfoString("something") + expect(x.interfaceConstantInfoString()).toBe("something") }); - test("Checking GeneratorProfile.implementationVariableInfoString.", () => { + test("Checking GeneratorProfile.implementationConstantInfoString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationVariableInfoString("something") - expect(x.implementationVariableInfoString()).toBe("something") + x.setImplementationConstantInfoString("something") + expect(x.implementationConstantInfoString()).toBe("something") + }); + test("Checking GeneratorProfile.interfaceComputedConstantInfoString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setInterfaceComputedConstantInfoString("something") + expect(x.interfaceComputedConstantInfoString()).toBe("something") + }); + test("Checking GeneratorProfile.implementationComputedConstantInfoString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setImplementationComputedConstantInfoString("something") + expect(x.implementationComputedConstantInfoString()).toBe("something") + }); + test("Checking GeneratorProfile.interfaceAlgebraicInfoString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setInterfaceAlgebraicInfoString("something") + expect(x.interfaceAlgebraicInfoString()).toBe("something") + }); + test("Checking GeneratorProfile.implementationAlgebraicInfoString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setImplementationAlgebraicInfoString("something") + expect(x.implementationAlgebraicInfoString()).toBe("something") + }); + test("Checking GeneratorProfile.interfaceExternalInfoString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setInterfaceExternalInfoString("something") + expect(x.interfaceExternalInfoString()).toBe("something") + }); + test("Checking GeneratorProfile.implementationExternalInfoString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setImplementationExternalInfoString("something") + expect(x.implementationExternalInfoString()).toBe("something") }); test("Checking GeneratorProfile.variableInfoEntryString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 7b3cbddb1..ce31fc92c 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -907,6 +907,42 @@ def test_implementation_state_info_string(self): g.setImplementationStateInfoString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationStateInfoString()) + def test_implementation_constant_info_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('const VariableInfo CONSTANT_INFO[] = {\n[CODE]};\n', g.implementationConstantInfoString()) + g.setImplementationConstantInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationConstantInfoString()) + + def test_implementation_computed_constant_info_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('const VariableInfo COMPUTED_CONSTANT_INFO[] = {\n[CODE]};\n', g.implementationComputedConstantInfoString()) + g.setImplementationComputedConstantInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputedConstantInfoString()) + + def test_implementation_algebraic_info_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('const VariableInfo ALGEBRAIC_INFO[] = {\n[CODE]};\n', g.implementationAlgebraicInfoString()) + g.setImplementationAlgebraicInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationAlgebraicInfoString()) + + def test_implementation_external_info_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('const VariableInfo EXTERNAL_INFO[] = {\n[CODE]};\n', g.implementationExternalInfoString()) + g.setImplementationExternalInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationExternalInfoString()) + def test_implementation_constant_count_string(self): from libcellml import GeneratorProfile @@ -943,16 +979,6 @@ def test_implementation_external_count_string(self): g.setImplementationExternalCountString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationExternalCountString()) - def test_implementation_variable_info_string(self): - from libcellml import GeneratorProfile - - g = GeneratorProfile() - - self.assertEqual('const VariableInfo VARIABLE_INFO[] = {\n[CODE]};\n', - g.implementationVariableInfoString()) - g.setImplementationVariableInfoString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationVariableInfoString()) - def test_implementation_version_string(self): from libcellml import GeneratorProfile @@ -1142,6 +1168,42 @@ def test_interface_state_info_string(self): g.setInterfaceStateInfoString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceStateInfoString()) + def test_interface_constant_info_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('extern const VariableInfo CONSTANT_INFO[];\n', g.interfaceConstantInfoString()) + g.setInterfaceConstantInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceConstantInfoString()) + + def test_interface_computed_constant_info_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('extern const VariableInfo COMPUTED_CONSTANT_INFO[];\n', g.interfaceComputedConstantInfoString()) + g.setInterfaceComputedConstantInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputedConstantInfoString()) + + def test_interface_algebraic_info_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('extern const VariableInfo ALGEBRAIC_INFO[];\n', g.interfaceAlgebraicInfoString()) + g.setInterfaceAlgebraicInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceAlgebraicInfoString()) + + def test_interface_external_info_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('extern const VariableInfo EXTERNAL_INFO[];\n', g.interfaceExternalInfoString()) + g.setInterfaceExternalInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceExternalInfoString()) + def test_interface_constant_count_string(self): from libcellml import GeneratorProfile @@ -1178,15 +1240,6 @@ def test_interface_external_count_string(self): g.setInterfaceExternalCountString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceExternalCountString()) - def test_interface_variable_info_string(self): - from libcellml import GeneratorProfile - - g = GeneratorProfile() - - self.assertEqual('extern const VariableInfo VARIABLE_INFO[];\n', g.interfaceVariableInfoString()) - g.setInterfaceVariableInfoString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceVariableInfoString()) - def test_interface_version_string(self): from libcellml import GeneratorProfile diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 096e40b79..2a6a53ea7 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -736,7 +736,13 @@ TEST(Coverage, generator) profile->setImplementationStateInfoString(""); - profile->setImplementationVariableInfoString(""); + profile->setImplementationConstantInfoString(""); + + profile->setImplementationComputedConstantInfoString(""); + + profile->setImplementationAlgebraicInfoString(""); + + profile->setImplementationExternalInfoString(""); profile->setVariableInfoEntryString(""); @@ -823,8 +829,17 @@ TEST(Coverage, generator) profile->setInterfaceStateInfoString(""); profile->setImplementationStateInfoString(""); - profile->setInterfaceVariableInfoString(""); - profile->setImplementationVariableInfoString(""); + profile->setInterfaceConstantInfoString(""); + profile->setImplementationConstantInfoString(""); + + profile->setInterfaceComputedConstantInfoString(""); + profile->setImplementationComputedConstantInfoString(""); + + profile->setInterfaceAlgebraicInfoString(""); + profile->setImplementationAlgebraicInfoString(""); + + profile->setInterfaceExternalInfoString(""); + profile->setImplementationExternalInfoString(""); profile->setVariableInfoEntryString(""); diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index a055f922b..7f079b5c0 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -346,11 +346,29 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "};\n", generatorProfile->implementationStateInfoString()); - EXPECT_EQ("extern const VariableInfo VARIABLE_INFO[];\n", generatorProfile->interfaceVariableInfoString()); - EXPECT_EQ("const VariableInfo VARIABLE_INFO[] = {\n" + EXPECT_EQ("extern const VariableInfo CONSTANT_INFO[];\n", generatorProfile->interfaceConstantInfoString()); + EXPECT_EQ("const VariableInfo CONSTANT_INFO[] = {\n" "[CODE]" "};\n", - generatorProfile->implementationVariableInfoString()); + generatorProfile->implementationConstantInfoString()); + + EXPECT_EQ("extern const VariableInfo COMPUTED_CONSTANT_INFO[];\n", generatorProfile->interfaceComputedConstantInfoString()); + EXPECT_EQ("const VariableInfo COMPUTED_CONSTANT_INFO[] = {\n" + "[CODE]" + "};\n", + generatorProfile->implementationComputedConstantInfoString()); + + EXPECT_EQ("extern const VariableInfo ALGEBRAIC_INFO[];\n", generatorProfile->interfaceAlgebraicInfoString()); + EXPECT_EQ("const VariableInfo ALGEBRAIC_INFO[] = {\n" + "[CODE]" + "};\n", + generatorProfile->implementationAlgebraicInfoString()); + + EXPECT_EQ("extern const VariableInfo EXTERNAL_INFO[];\n", generatorProfile->interfaceExternalInfoString()); + EXPECT_EQ("const VariableInfo EXTERNAL_INFO[] = {\n" + "[CODE]" + "};\n", + generatorProfile->implementationExternalInfoString()); EXPECT_EQ("{\"[NAME]\", \"[UNITS]\", \"[COMPONENT]\", [TYPE]}", generatorProfile->variableInfoEntryString()); @@ -908,8 +926,17 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setInterfaceStateInfoString(value); generatorProfile->setImplementationStateInfoString(value); - generatorProfile->setInterfaceVariableInfoString(value); - generatorProfile->setImplementationVariableInfoString(value); + generatorProfile->setInterfaceConstantInfoString(value); + generatorProfile->setImplementationConstantInfoString(value); + + generatorProfile->setInterfaceComputedConstantInfoString(value); + generatorProfile->setImplementationComputedConstantInfoString(value); + + generatorProfile->setInterfaceAlgebraicInfoString(value); + generatorProfile->setImplementationAlgebraicInfoString(value); + + generatorProfile->setInterfaceExternalInfoString(value); + generatorProfile->setImplementationExternalInfoString(value); generatorProfile->setVariableInfoEntryString(value); @@ -1048,8 +1075,17 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->interfaceStateInfoString()); EXPECT_EQ(value, generatorProfile->implementationStateInfoString()); - EXPECT_EQ(value, generatorProfile->interfaceVariableInfoString()); - EXPECT_EQ(value, generatorProfile->implementationVariableInfoString()); + EXPECT_EQ(value, generatorProfile->interfaceConstantInfoString()); + EXPECT_EQ(value, generatorProfile->implementationConstantInfoString()); + + EXPECT_EQ(value, generatorProfile->interfaceComputedConstantInfoString()); + EXPECT_EQ(value, generatorProfile->implementationComputedConstantInfoString()); + + EXPECT_EQ(value, generatorProfile->interfaceAlgebraicInfoString()); + EXPECT_EQ(value, generatorProfile->implementationAlgebraicInfoString()); + + EXPECT_EQ(value, generatorProfile->interfaceExternalInfoString()); + EXPECT_EQ(value, generatorProfile->implementationExternalInfoString()); EXPECT_EQ(value, generatorProfile->variableInfoEntryString()); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index aa1b69f19..c354ffd2c 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -19,14 +19,17 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_component", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"m", "dimensionless", "my_component", CONSTANT}, {"n", "dimensionless", "my_component", CONSTANT}, {"o", "dimensionless", "my_component", CONSTANT}, {"p", "dimensionless", "my_component", CONSTANT}, {"q", "dimensionless", "my_component", CONSTANT}, {"r", "dimensionless", "my_component", CONSTANT}, - {"s", "dimensionless", "my_component", CONSTANT}, + {"s", "dimensionless", "my_component", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"eqnEq", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnEqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnNeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, @@ -226,7 +229,10 @@ const VariableInfo VARIABLE_INFO[] = { {"eqnCoverageForRootOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnCoverageForMinusUnary", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnComputedConstant1", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnComputedConstant2", "dimensionless", "my_component", COMPUTED_CONSTANT}, + {"eqnComputedConstant2", "dimensionless", "my_component", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"eqnNlaVariable1", "dimensionless", "my_component", ALGEBRAIC}, {"eqnNlaVariable2", "dimensionless", "my_component", ALGEBRAIC} }; diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index e05872689..07d230338 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 01e2454c3..b81232df9 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -19,14 +19,17 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_component", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"m", "dimensionless", "my_component", CONSTANT}, {"n", "dimensionless", "my_component", CONSTANT}, {"o", "dimensionless", "my_component", CONSTANT}, {"p", "dimensionless", "my_component", CONSTANT}, {"q", "dimensionless", "my_component", CONSTANT}, {"r", "dimensionless", "my_component", CONSTANT}, - {"s", "dimensionless", "my_component", CONSTANT}, + {"s", "dimensionless", "my_component", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"eqnEq", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnEqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnNeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, @@ -226,7 +229,10 @@ const VariableInfo VARIABLE_INFO[] = { {"eqnCoverageForRootOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnCoverageForMinusUnary", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"eqnComputedConstant1", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnComputedConstant2", "dimensionless", "my_component", COMPUTED_CONSTANT}, + {"eqnComputedConstant2", "dimensionless", "my_component", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"eqnNlaVariable1", "dimensionless", "my_component", ALGEBRAIC}, {"eqnNlaVariable2", "dimensionless", "my_component", ALGEBRAIC} }; diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index ef3a093e6..7bb7462be 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesVector(); double * createVariablesArray(); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index cd3746478..c7b36b99d 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -23,18 +23,20 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} -] +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} + -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "m", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "n", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "o", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "p", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "q", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "r", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "s", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "s", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "eqnEq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnNeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, @@ -234,7 +236,10 @@ class VariableType(Enum): {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC}, {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 07afa2a6b..bea011a82 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -23,18 +23,20 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} -] +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} + -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "m", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "n", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "o", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "p", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "q", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, {"name": "r", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "s", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, + {"name": "s", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "eqnEq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnNeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, @@ -234,7 +236,10 @@ class VariableType(Enum): {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC}, {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index ef4da021e..93b538b35 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -12,11 +12,17 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 2; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"x", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, {"a", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT} }; +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createVariablesArray() { double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 37cec86d3..4d448046d 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -13,8 +13,17 @@ const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; const size_t EXTERNAL_COUNT = 1; -const VariableInfo VARIABLE_INFO[] = { - {"x", "dimensionless", "my_algebraic_eqn", ALGEBRAIC}, +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { + {"x", "dimensionless", "my_algebraic_eqn", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"a", "dimensionless", "my_algebraic_eqn", EXTERNAL} }; diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index 976333877..da181acb2 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -26,7 +26,10 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 7168da1a3..267f46df4 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -20,8 +20,17 @@ class VariableType(Enum): EXTERNAL = 3 -VARIABLE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.ALGEBRAIC}, +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index 8b9a1fb66..a14bcb399 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -24,7 +24,9 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index c3b91e3df..f4989919e 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -18,11 +18,17 @@ class VariableType(Enum): ALGEBRAIC = 2 -VARIABLE_INFO = [ +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT} ] +ALGEBRAIC_INFO = [ +] + def create_variables_array(): return [nan]*VARIABLE_COUNT diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index b9b36994d..55fb1236a 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -12,11 +12,17 @@ const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VARIABLE_INFO[] = { - {"a", "dimensionless", "my_algebraic_eqn", CONSTANT}, +const VariableInfo CONSTANT_INFO[] = { + {"a", "dimensionless", "my_algebraic_eqn", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"x", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT} }; +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createVariablesArray() { double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index 8b9a1fb66..a14bcb399 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -24,7 +24,9 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index 034cacb34..a6562fdf5 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -18,11 +18,17 @@ class VariableType(Enum): ALGEBRAIC = 2 -VARIABLE_INFO = [ - {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.CONSTANT}, +CONSTANT_INFO = [ + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT} ] +ALGEBRAIC_INFO = [ +] + def create_variables_array(): return [nan]*VARIABLE_COUNT diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index 5e2571905..0c647741f 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -12,10 +12,16 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"x", "dimensionless", "my_component", COMPUTED_CONSTANT} }; +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createVariablesArray() { double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index d26413c67..2e7b0dd0b 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -24,7 +24,9 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index b36b39ca8..8c32d995f 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -18,10 +18,16 @@ class VariableType(Enum): ALGEBRAIC = 2 -VARIABLE_INFO = [ +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} ] +ALGEBRAIC_INFO = [ +] + def create_variables_array(): return [nan]*VARIABLE_COUNT diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 5f56854dd..ec215a064 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -19,8 +19,14 @@ const VariableInfo STATE_INFO[] = { {"v", "dimensionless", "my_ode", STATE} }; -const VariableInfo VARIABLE_INFO[] = { - {"a", "per_s", "my_ode", COMPUTED_CONSTANT}, +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"a", "per_s", "my_ode", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"x", "per_s", "my_algebraic_eqn", ALGEBRAIC} }; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index 1eeee2f1e..bb606064c 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index b68e0ff04..9a708f235 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -23,12 +23,17 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "v", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "v", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "a", "units": "per_s", "component": "my_ode", "type": VariableType.COMPUTED_CONSTANT} ] -VARIABLE_INFO = [ - {"name": "a", "units": "per_s", "component": "my_ode", "type": VariableType.COMPUTED_CONSTANT}, +ALGEBRAIC_INFO = [ {"name": "x", "units": "per_s", "component": "my_algebraic_eqn", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 4449ebc70..1ca280481 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -19,8 +19,14 @@ const VariableInfo STATE_INFO[] = { {"v", "dimensionless", "my_component", STATE} }; -const VariableInfo VARIABLE_INFO[] = { - {"a", "per_s", "my_component", COMPUTED_CONSTANT}, +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"a", "per_s", "my_component", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"x", "per_s", "my_component", ALGEBRAIC} }; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index ca79cc5f2..ec1099767 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 3228a39f5..b0f2b7a22 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -23,12 +23,17 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "v", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "v", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "a", "units": "per_s", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} ] -VARIABLE_INFO = [ - {"name": "a", "units": "per_s", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, +ALGEBRAIC_INFO = [ {"name": "x", "units": "per_s", "component": "my_component", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 32f1de15f..3a887564d 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -19,8 +19,14 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_ode", STATE} }; -const VariableInfo VARIABLE_INFO[] = { - {"a", "per_s", "my_ode", COMPUTED_CONSTANT}, +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"a", "per_s", "my_ode", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"xx", "dimensionless", "my_algebraic_eqn", ALGEBRAIC} }; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index d2a3025e3..ca2d89ac4 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 44baf1642..30fb1833d 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -23,12 +23,17 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "a", "units": "per_s", "component": "my_ode", "type": VariableType.COMPUTED_CONSTANT} ] -VARIABLE_INFO = [ - {"name": "a", "units": "per_s", "component": "my_ode", "type": VariableType.COMPUTED_CONSTANT}, +ALGEBRAIC_INFO = [ {"name": "xx", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 352e5bd87..c25242a83 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -19,8 +19,14 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_model", STATE} }; -const VariableInfo VARIABLE_INFO[] = { - {"a", "per_s", "my_model", COMPUTED_CONSTANT}, +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"a", "per_s", "my_model", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"xx", "dimensionless", "my_model", ALGEBRAIC} }; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index cfae2b1d2..204f85667 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 1a8d75e50..81450104a 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -23,12 +23,17 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "my_model", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_model", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_model", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "a", "units": "per_s", "component": "my_model", "type": VariableType.COMPUTED_CONSTANT} ] -VARIABLE_INFO = [ - {"name": "a", "units": "per_s", "component": "my_model", "type": VariableType.COMPUTED_CONSTANT}, +ALGEBRAIC_INFO = [ {"name": "xx", "units": "dimensionless", "component": "my_model", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 78af0f1c1..9729fbf02 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -12,10 +12,16 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 3; const size_t ALGEBRAIC_COUNT = 1; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"b", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, {"c", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, - {"d", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, + {"d", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"a", "dimensionless", "my_algebraic_eqn", ALGEBRAIC} }; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index 5e1f7d6b8..0dc47b9c0 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -13,10 +13,19 @@ const size_t COMPUTED_CONSTANT_COUNT = 3; const size_t ALGEBRAIC_COUNT = 0; const size_t EXTERNAL_COUNT = 1; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"b", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, {"c", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, - {"d", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, + {"d", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { +}; + +const VariableInfo EXTERNAL_INFO[] = { {"a", "dimensionless", "my_algebraic_eqn", EXTERNAL} }; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index 976333877..da181acb2 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -26,7 +26,10 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index ed3205098..abab654ef 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -20,10 +20,19 @@ class VariableType(Enum): EXTERNAL = 3 -VARIABLE_INFO = [ +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ +] + +EXTERNAL_INFO = [ {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index 8b9a1fb66..a14bcb399 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -24,7 +24,9 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 1f349758b..47a6536ef 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -18,10 +18,16 @@ class VariableType(Enum): ALGEBRAIC = 2 -VARIABLE_INFO = [ +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index eb6d409ad..10613b828 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -12,7 +12,13 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 3; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"x", "dimensionless", "my_algebraic_system", ALGEBRAIC}, {"y", "dimensionless", "my_algebraic_system", ALGEBRAIC}, {"z", "dimensionless", "my_algebraic_system", ALGEBRAIC} diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index 69ce3f676..6633bbe21 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -24,7 +24,9 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index de50e042e..797157fd5 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -18,7 +18,13 @@ class VariableType(Enum): ALGEBRAIC = 2 -VARIABLE_INFO = [ +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, {"name": "z", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC} diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index a22f00fad..5596bf8a6 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -13,7 +13,16 @@ const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; const size_t EXTERNAL_COUNT = 3; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { +}; + +const VariableInfo EXTERNAL_INFO[] = { {"x", "dimensionless", "my_algebraic_system", EXTERNAL}, {"y", "dimensionless", "my_algebraic_system", EXTERNAL}, {"z", "dimensionless", "my_algebraic_system", EXTERNAL} diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index 0c3b6b4a5..a2a7d679f 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -26,7 +26,10 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index c79c81613..63ee6d6d8 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -20,7 +20,16 @@ class VariableType(Enum): EXTERNAL = 3 -VARIABLE_INFO = [ +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ +] + +EXTERNAL_INFO = [ {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.EXTERNAL}, {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.EXTERNAL}, {"name": "z", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.EXTERNAL} diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index be81938b4..4cebe90c9 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -12,10 +12,16 @@ const size_t CONSTANT_COUNT = 2; const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 3; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"x", "dimensionless", "my_algebraic_system", CONSTANT}, - {"y", "dimensionless", "my_algebraic_system", CONSTANT}, - {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT}, + {"y", "dimensionless", "my_algebraic_system", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"d", "dimensionless", "my_algebraic_system", ALGEBRAIC}, {"b", "dimensionless", "my_algebraic_system", ALGEBRAIC}, {"c", "dimensionless", "my_algebraic_system", ALGEBRAIC} diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index 69ce3f676..6633bbe21 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -24,7 +24,9 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index a10c6ed59..4c2a52ea3 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -18,10 +18,16 @@ class VariableType(Enum): ALGEBRAIC = 2 -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT}, - {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT}, - {"name": "a", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "a", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "d", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, {"name": "b", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, {"name": "c", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC} diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index df91e1567..bb02166a7 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -12,10 +12,16 @@ const size_t CONSTANT_COUNT = 2; const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 3; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"x", "dimensionless", "my_algebraic_system", CONSTANT}, - {"y", "dimensionless", "my_algebraic_system", CONSTANT}, - {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT}, + {"y", "dimensionless", "my_algebraic_system", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"c", "dimensionless", "my_algebraic_system", ALGEBRAIC}, {"b", "dimensionless", "my_algebraic_system", ALGEBRAIC}, {"d", "dimensionless", "my_algebraic_system", ALGEBRAIC} diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index 69ce3f676..6633bbe21 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -24,7 +24,9 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 3272ba839..232ab46ef 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -18,10 +18,16 @@ class VariableType(Enum): ALGEBRAIC = 2 -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT}, - {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT}, - {"name": "a", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "a", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "c", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, {"name": "b", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, {"name": "d", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC} diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index bfdee7fae..d53d3e1fd 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -12,11 +12,17 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 2; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"x", "dimensionless", "my_component", COMPUTED_CONSTANT}, {"y", "dimensionless", "my_component", COMPUTED_CONSTANT} }; +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createVariablesArray() { double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index d26413c67..2e7b0dd0b 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -24,7 +24,9 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 020c15fc0..9b2aca671 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -18,11 +18,17 @@ class VariableType(Enum): ALGEBRAIC = 2 -VARIABLE_INFO = [ +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, {"name": "y", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} ] +ALGEBRAIC_INFO = [ +] + def create_variables_array(): return [nan]*VARIABLE_COUNT diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index 1d2073048..48d3bfc77 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -12,13 +12,19 @@ const size_t CONSTANT_COUNT = 2; const size_t COMPUTED_CONSTANT_COUNT = 2; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"L", "centimeter", "cell_geometry", CONSTANT}, - {"rad", "centimeter", "cell_geometry", CONSTANT}, + {"rad", "centimeter", "cell_geometry", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"vcell", "microlitre", "cell_geometry", COMPUTED_CONSTANT}, {"vss", "microlitre", "cell_geometry", COMPUTED_CONSTANT} }; +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createVariablesArray() { double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 4fe760dd4..1ca71d6f6 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -13,9 +13,18 @@ const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; const size_t EXTERNAL_COUNT = 2; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"vcell", "microlitre", "cell_geometry", ALGEBRAIC}, - {"vss", "microlitre", "cell_geometry", ALGEBRAIC}, + {"vss", "microlitre", "cell_geometry", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"L", "centimeter", "cell_geometry", EXTERNAL}, {"rad", "centimeter", "cell_geometry", EXTERNAL} }; diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 413845298..84cfc4521 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -26,7 +26,10 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 4c1af8bb9..15e494636 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -20,9 +20,18 @@ class VariableType(Enum): EXTERNAL = 3 -VARIABLE_INFO = [ +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ {"name": "vcell", "units": "microlitre", "component": "cell_geometry", "type": VariableType.ALGEBRAIC}, - {"name": "vss", "units": "microlitre", "component": "cell_geometry", "type": VariableType.ALGEBRAIC}, + {"name": "vss", "units": "microlitre", "component": "cell_geometry", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "L", "units": "centimeter", "component": "cell_geometry", "type": VariableType.EXTERNAL}, {"name": "rad", "units": "centimeter", "component": "cell_geometry", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index d291cbc39..9dc3b9499 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -24,7 +24,9 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index b25e428a5..1ef05bded 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -18,13 +18,19 @@ class VariableType(Enum): ALGEBRAIC = 2 -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "L", "units": "centimeter", "component": "cell_geometry", "type": VariableType.CONSTANT}, - {"name": "rad", "units": "centimeter", "component": "cell_geometry", "type": VariableType.CONSTANT}, + {"name": "rad", "units": "centimeter", "component": "cell_geometry", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "vcell", "units": "microlitre", "component": "cell_geometry", "type": VariableType.COMPUTED_CONSTANT}, {"name": "vss", "units": "microlitre", "component": "cell_geometry", "type": VariableType.COMPUTED_CONSTANT} ] +ALGEBRAIC_INFO = [ +] + def create_variables_array(): return [nan]*VARIABLE_COUNT diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 3f59baaf8..f304992cb 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -20,7 +20,13 @@ const VariableInfo STATE_INFO[] = { {"x", "mM", "circle_x", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"local_complex_maths", "mM", "circle_sibling", ALGEBRAIC}, {"two_x", "milli_mole", "circle_x_sibling", ALGEBRAIC} }; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index 91a2bbdb9..9719caec0 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 42799d811..745325178 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -23,12 +23,17 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "y", "units": "mM", "component": "circle_y_implementation", "type": VariableType.STATE}, +STATE_INFO = {"name": "y", "units": "mM", "component": "circle_y_implementation", "type": VariableType.STATE}, {"name": "x", "units": "mM", "component": "circle_x", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +ALGEBRAIC_INFO = [ {"name": "local_complex_maths", "units": "mM", "component": "circle_sibling", "type": VariableType.ALGEBRAIC}, {"name": "two_x", "units": "milli_mole", "component": "circle_x_sibling", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index b03cf8648..cf83a2261 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -18,7 +18,7 @@ class VariableType(Enum): ALGEBRAIC = 2 -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "E", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "q_Ao", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, @@ -27,10 +27,16 @@ class VariableType(Enum): {"name": "P_2", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, + {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "v", "units": "fmol_per_sec", "component": "SLC_template3_ss", "type": VariableType.COMPUTED_CONSTANT} ] +ALGEBRAIC_INFO = [ +] + def create_variables_array(): return [nan]*VARIABLE_COUNT diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index e8e13541c..cf52db26b 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -19,10 +19,16 @@ const VariableInfo STATE_INFO[] = { {"x", "mV", "main", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"k", "mV", "constants", CONSTANT} }; +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createStatesArray() { double *res = (double *) malloc(STATE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index e95d12eb1..420928348 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 5aae09a47..f32c24fe0 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -23,14 +23,19 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "mV", "component": "main", "type": VariableType.STATE} -] +STATE_INFO = {"name": "x", "units": "mV", "component": "main", "type": VariableType.STATE} + -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "k", "units": "mV", "component": "constants", "type": VariableType.CONSTANT} ] +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ +] + def create_states_array(): return [nan]*STATE_COUNT diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 21638fba9..a3494f54d 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -12,12 +12,18 @@ const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 2; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VARIABLE_INFO[] = { - {"k", "mM", "constants", CONSTANT}, +const VariableInfo CONSTANT_INFO[] = { + {"k", "mM", "constants", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"x", "mM", "main", COMPUTED_CONSTANT}, {"y", "M", "main", COMPUTED_CONSTANT} }; +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createVariablesArray() { double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index 435deb74f..2e51e8fd1 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -24,7 +24,9 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index d2ee195c5..bc4e24cb4 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -18,12 +18,18 @@ class VariableType(Enum): ALGEBRAIC = 2 -VARIABLE_INFO = [ - {"name": "k", "units": "mM", "component": "constants", "type": VariableType.CONSTANT}, +CONSTANT_INFO = [ + {"name": "k", "units": "mM", "component": "constants", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "x", "units": "mM", "component": "main", "type": VariableType.COMPUTED_CONSTANT}, {"name": "y", "units": "M", "component": "main", "type": VariableType.COMPUTED_CONSTANT} ] +ALGEBRAIC_INFO = [ +] + def create_variables_array(): return [nan]*VARIABLE_COUNT diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 603a1eab3..302ea642f 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -19,7 +19,13 @@ const VariableInfo STATE_INFO[] = { {"k", "mM", "states", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"x", "mM", "main", ALGEBRAIC}, {"y", "M", "main", ALGEBRAIC} }; diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index e95d12eb1..420928348 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index f74588e12..4a031e253 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -23,11 +23,16 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "k", "units": "mM", "component": "states", "type": VariableType.STATE} +STATE_INFO = {"name": "k", "units": "mM", "component": "states", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +ALGEBRAIC_INFO = [ {"name": "x", "units": "mM", "component": "main", "type": VariableType.ALGEBRAIC}, {"name": "y", "units": "M", "component": "main", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 34c1bca1f..550d7ad85 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -19,7 +19,13 @@ const VariableInfo STATE_INFO[] = { {"k", "mM", "states", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"x", "mM", "main", ALGEBRAIC}, {"y", "M", "main", ALGEBRAIC} }; diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index e95d12eb1..420928348 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index ec43146e3..f5bfca28f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -23,11 +23,16 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "k", "units": "mM", "component": "states", "type": VariableType.STATE} +STATE_INFO = {"name": "k", "units": "mM", "component": "states", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +ALGEBRAIC_INFO = [ {"name": "x", "units": "mM", "component": "main", "type": VariableType.ALGEBRAIC}, {"name": "y", "units": "M", "component": "main", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index c0db3b3a3..03bb266d5 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -20,7 +20,13 @@ const VariableInfo STATE_INFO[] = { {"k2", "M", "main", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { }; double * createStatesArray() diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index bd4dd923e..46d3f1cf8 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index 86e48a995..d3f5a756d 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -23,12 +23,17 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "k1", "units": "mM", "component": "main", "type": VariableType.STATE}, +STATE_INFO = {"name": "k1", "units": "mM", "component": "main", "type": VariableType.STATE}, {"name": "k2", "units": "M", "component": "main", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +ALGEBRAIC_INFO = [ ] diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index 27bf38fab..2cb41fddf 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -20,11 +20,17 @@ const VariableInfo STATE_INFO[] = { {"k2", "M", "main", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"k1_cst", "mM", "constants", CONSTANT}, {"k2_cst", "mM", "constants", CONSTANT} }; +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createStatesArray() { double *res = (double *) malloc(STATE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index fc9911e7e..ef9422431 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 9e1edd3c4..0ad4df919 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -23,16 +23,21 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "k1", "units": "mM", "component": "main", "type": VariableType.STATE}, +STATE_INFO = {"name": "k1", "units": "mM", "component": "main", "type": VariableType.STATE}, {"name": "k2", "units": "M", "component": "main", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "k1_cst", "units": "mM", "component": "constants", "type": VariableType.CONSTANT}, {"name": "k2_cst", "units": "mM", "component": "constants", "type": VariableType.CONSTANT} ] +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ +] + def create_states_array(): return [nan]*STATE_COUNT diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index f0e1d42ba..f29503e6a 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -20,7 +20,13 @@ const VariableInfo STATE_INFO[] = { {"y", "dimensionless", "main", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { }; double * createStatesArray() diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index 3f1fb63fd..35acb1470 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index e14df017f..f86e8920c 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -23,12 +23,17 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "main", "type": VariableType.STATE}, +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "main", "type": VariableType.STATE}, {"name": "y", "units": "dimensionless", "component": "main", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +ALGEBRAIC_INFO = [ ] diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index cd6840c59..05950cf51 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -21,7 +21,13 @@ const VariableInfo STATE_INFO[] = { {"x", "metre", "t_in_ks", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { }; double * createStatesArray() diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 123e68564..ce44fd3c1 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index ac4a5b309..751996429 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -23,13 +23,18 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "metre", "component": "t_in_s", "type": VariableType.STATE}, +STATE_INFO = {"name": "x", "units": "metre", "component": "t_in_s", "type": VariableType.STATE}, {"name": "x", "units": "metre", "component": "t_in_ms", "type": VariableType.STATE}, {"name": "x", "units": "metre", "component": "t_in_ks", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +ALGEBRAIC_INFO = [ ] diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 3b8e5e3bc..c35d824f1 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -20,12 +20,18 @@ const VariableInfo STATE_INFO[] = { {"v_3", "C_per_s", "main", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"v_in", "C_per_s", "main", CONSTANT}, {"v_out", "C_per_s", "main", CONSTANT}, {"C", "C2_per_J", "main", CONSTANT}, {"R", "Js_per_C2", "main", CONSTANT}, - {"L", "Js2_per_C2", "main", CONSTANT}, + {"L", "Js2_per_C2", "main", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"v_1", "C_per_s", "main", ALGEBRAIC}, {"v_2", "C_per_s", "main", ALGEBRAIC}, {"u_1", "J_per_C", "main", ALGEBRAIC}, diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 2bcb43579..8ebd938f3 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 50658a4db..3c39a8b8c 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -23,17 +23,22 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "main", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "q_1", "units": "coulomb", "component": "main", "type": VariableType.STATE}, +STATE_INFO = {"name": "q_1", "units": "coulomb", "component": "main", "type": VariableType.STATE}, {"name": "v_3", "units": "C_per_s", "component": "main", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "v_in", "units": "C_per_s", "component": "main", "type": VariableType.CONSTANT}, {"name": "v_out", "units": "C_per_s", "component": "main", "type": VariableType.CONSTANT}, {"name": "C", "units": "C2_per_J", "component": "main", "type": VariableType.CONSTANT}, {"name": "R", "units": "Js_per_C2", "component": "main", "type": VariableType.CONSTANT}, - {"name": "L", "units": "Js2_per_C2", "component": "main", "type": VariableType.CONSTANT}, + {"name": "L", "units": "Js2_per_C2", "component": "main", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ {"name": "v_1", "units": "C_per_s", "component": "main", "type": VariableType.ALGEBRAIC}, {"name": "v_2", "units": "C_per_s", "component": "main", "type": VariableType.ALGEBRAIC}, {"name": "u_1", "units": "J_per_C", "component": "main", "type": VariableType.ALGEBRAIC}, diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 7bbb98144..796c72dbf 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -19,7 +19,13 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_component", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"a", "second", "my_component", ALGEBRAIC}, {"b", "second", "my_component", ALGEBRAIC} }; diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 676c75fec..3e6d21a18 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index 5ed89e910..98091ed39 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -23,11 +23,16 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +ALGEBRAIC_INFO = [ {"name": "a", "units": "second", "component": "my_component", "type": VariableType.ALGEBRAIC}, {"name": "b", "units": "second", "component": "my_component", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 0e25bc096..51bfd4d93 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -51,7 +51,7 @@ const VariableInfo STATE_INFO[] = { {"a", "dimensionless", "i_KACh_a_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"ACh", "millimolar", "Rate_modulation_experiments", CONSTANT}, {"Iso_1_uM", "dimensionless", "Rate_modulation_experiments", CONSTANT}, {"Nao", "millimolar", "Ionic_values", CONSTANT}, @@ -142,7 +142,10 @@ const VariableInfo VARIABLE_INFO[] = { {"g_Kr", "microS", "i_Kr", CONSTANT}, {"g_Ks_", "microS", "i_Ks", CONSTANT}, {"ACh_on", "dimensionless", "i_KACh", CONSTANT}, - {"g_KACh", "microS", "i_KACh", CONSTANT}, + {"g_KACh", "microS", "i_KACh", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"RTONF", "millivolt", "Membrane", COMPUTED_CONSTANT}, {"E_K", "millivolt", "Ionic_values", COMPUTED_CONSTANT}, {"V_i", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, @@ -167,7 +170,10 @@ const VariableInfo VARIABLE_INFO[] = { {"Iso_slope_dL", "dimensionless", "i_CaL_dL_gate", COMPUTED_CONSTANT}, {"g_Ks", "microS", "i_Ks", COMPUTED_CONSTANT}, {"Iso_shift", "millivolt", "i_Ks_n_gate", COMPUTED_CONSTANT}, - {"alpha_a", "per_second", "i_KACh_a_gate", COMPUTED_CONSTANT}, + {"alpha_a", "per_second", "i_KACh_a_gate", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"E_Na", "millivolt", "Ionic_values", ALGEBRAIC}, {"Nai", "millimolar", "Nai_concentration", ALGEBRAIC}, {"E_Ca", "millivolt", "Ionic_values", ALGEBRAIC}, diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index e94e9dec0..1fee5d4d2 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 413cd1d94..ef40ae85f 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -23,8 +23,7 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "Ca_sub", "units": "millimolar", "component": "Ca_dynamics", "type": VariableType.STATE}, +STATE_INFO = {"name": "Ca_sub", "units": "millimolar", "component": "Ca_dynamics", "type": VariableType.STATE}, {"name": "Nai_", "units": "millimolar", "component": "Nai_concentration", "type": VariableType.STATE}, {"name": "Ca_jsr", "units": "millimolar", "component": "Ca_dynamics", "type": VariableType.STATE}, {"name": "O", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.STATE}, @@ -57,9 +56,9 @@ class VariableType(Enum): {"name": "paS", "units": "dimensionless", "component": "i_Kr_pa_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "i_Ks_n_gate", "type": VariableType.STATE}, {"name": "a", "units": "dimensionless", "component": "i_KACh_a_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "ACh", "units": "millimolar", "component": "Rate_modulation_experiments", "type": VariableType.CONSTANT}, {"name": "Iso_1_uM", "units": "dimensionless", "component": "Rate_modulation_experiments", "type": VariableType.CONSTANT}, {"name": "Nao", "units": "millimolar", "component": "Ionic_values", "type": VariableType.CONSTANT}, @@ -150,7 +149,10 @@ class VariableType(Enum): {"name": "g_Kr", "units": "microS", "component": "i_Kr", "type": VariableType.CONSTANT}, {"name": "g_Ks_", "units": "microS", "component": "i_Ks", "type": VariableType.CONSTANT}, {"name": "ACh_on", "units": "dimensionless", "component": "i_KACh", "type": VariableType.CONSTANT}, - {"name": "g_KACh", "units": "microS", "component": "i_KACh", "type": VariableType.CONSTANT}, + {"name": "g_KACh", "units": "microS", "component": "i_KACh", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "RTONF", "units": "millivolt", "component": "Membrane", "type": VariableType.COMPUTED_CONSTANT}, {"name": "E_K", "units": "millivolt", "component": "Ionic_values", "type": VariableType.COMPUTED_CONSTANT}, {"name": "V_i", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, @@ -175,7 +177,10 @@ class VariableType(Enum): {"name": "Iso_slope_dL", "units": "dimensionless", "component": "i_CaL_dL_gate", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_Ks", "units": "microS", "component": "i_Ks", "type": VariableType.COMPUTED_CONSTANT}, {"name": "Iso_shift", "units": "millivolt", "component": "i_Ks_n_gate", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "alpha_a", "units": "per_second", "component": "i_KACh_a_gate", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "alpha_a", "units": "per_second", "component": "i_KACh_a_gate", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "E_Na", "units": "millivolt", "component": "Ionic_values", "type": VariableType.ALGEBRAIC}, {"name": "Nai", "units": "millimolar", "component": "Nai_concentration", "type": VariableType.ALGEBRAIC}, {"name": "E_Ca", "units": "millivolt", "component": "Ionic_values", "type": VariableType.ALGEBRAIC}, diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 798a745ca..7717d14f1 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -33,7 +33,7 @@ const VariableInfo STATE_INFO[] = { {"y", "dimensionless", "hyperpolarisation_activated_current_y_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"dCell", "dimensionless", "membrane", CONSTANT}, {"Version", "dimensionless", "membrane", CONSTANT}, {"FCellConstant", "dimensionless", "membrane", CONSTANT}, @@ -143,7 +143,10 @@ const VariableInfo VARIABLE_INFO[] = { {"g_f_K_Centre_1DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_K_Periphery_1DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, {"g_f_K_Centre_0DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_K_Periphery_0DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, + {"g_f_K_Periphery_0DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"FCell", "dimensionless", "membrane", COMPUTED_CONSTANT}, {"Cm", "microF", "membrane", COMPUTED_CONSTANT}, {"i_Ca_p", "nanoA", "persistent_calcium_current", COMPUTED_CONSTANT}, @@ -166,7 +169,10 @@ const VariableInfo VARIABLE_INFO[] = { {"tau_P_i", "second", "rapid_delayed_rectifying_potassium_current_P_i_gate", COMPUTED_CONSTANT}, {"g_K_s", "microS", "slow_delayed_rectifying_potassium_current", COMPUTED_CONSTANT}, {"g_f_Na", "microS", "hyperpolarisation_activated_current", COMPUTED_CONSTANT}, - {"g_f_K", "microS", "hyperpolarisation_activated_current", COMPUTED_CONSTANT}, + {"g_f_K", "microS", "hyperpolarisation_activated_current", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_Na", "nanoA", "sodium_current", ALGEBRAIC}, {"i_p", "nanoA", "sodium_potassium_pump", ALGEBRAIC}, {"i_NaCa", "nanoA", "sodium_calcium_exchanger", ALGEBRAIC}, diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 2715ae2d9..5838d8bc8 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 4c0443449..01844df2c 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -23,8 +23,7 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, {"name": "m", "units": "dimensionless", "component": "sodium_current_m_gate", "type": VariableType.STATE}, {"name": "h1", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.STATE}, {"name": "h2", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.STATE}, @@ -39,9 +38,9 @@ class VariableType(Enum): {"name": "P_as", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate", "type": VariableType.STATE}, {"name": "xs", "units": "dimensionless", "component": "slow_delayed_rectifying_potassium_current_xs_gate", "type": VariableType.STATE}, {"name": "y", "units": "dimensionless", "component": "hyperpolarisation_activated_current_y_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "dCell", "units": "dimensionless", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "Version", "units": "dimensionless", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "FCellConstant", "units": "dimensionless", "component": "membrane", "type": VariableType.CONSTANT}, @@ -151,7 +150,10 @@ class VariableType(Enum): {"name": "g_f_K_Centre_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_K_Periphery_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, {"name": "g_f_K_Centre_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_K_Periphery_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, + {"name": "g_f_K_Periphery_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "FCell", "units": "dimensionless", "component": "membrane", "type": VariableType.COMPUTED_CONSTANT}, {"name": "Cm", "units": "microF", "component": "membrane", "type": VariableType.COMPUTED_CONSTANT}, {"name": "i_Ca_p", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.COMPUTED_CONSTANT}, @@ -174,7 +176,10 @@ class VariableType(Enum): {"name": "tau_P_i", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_K_s", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "g_f_Na", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_f_K", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "g_f_K", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "i_Na", "units": "nanoA", "component": "sodium_current", "type": VariableType.ALGEBRAIC}, {"name": "i_p", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.ALGEBRAIC}, {"name": "i_NaCa", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.ALGEBRAIC}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 1d4908a13..f917c7664 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -23,15 +23,21 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, @@ -40,7 +46,10 @@ const VariableInfo VARIABLE_INFO[] = { {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"i_Stim", "microA_per_cm2", "membrane", EXTERNAL} }; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index 8ae5a3e5d..5fb0b0dbc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -31,7 +31,10 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 5a01f6f0a..069d0600d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -25,22 +25,27 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, @@ -49,7 +54,10 @@ class VariableType(Enum): {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 68474ef4f..e031f85b4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -22,15 +22,21 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 69c72fb83..6d9bf826c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -23,14 +23,20 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, @@ -40,7 +46,10 @@ const VariableInfo VARIABLE_INFO[] = { {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"E_L", "millivolt", "leakage_current", EXTERNAL} }; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index 8ae5a3e5d..5fb0b0dbc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -31,7 +31,10 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 39e9f1d65..b8319e0fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -25,21 +25,26 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, @@ -49,7 +54,10 @@ class VariableType(Enum): {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index d9d05dbab..5637ee56e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -23,14 +23,20 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"E_R", "millivolt", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, @@ -40,7 +46,10 @@ const VariableInfo VARIABLE_INFO[] = { {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"Cm", "microF_per_cm2", "membrane", EXTERNAL} }; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index 8ae5a3e5d..5fb0b0dbc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -31,7 +31,10 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 3749793d0..bb2ac5e62 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -25,21 +25,26 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, @@ -49,7 +54,10 @@ class VariableType(Enum): {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 4048ffd58..4fd81f7a0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -22,15 +22,21 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index 2379ada7d..7a76b71af 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index cbeb56196..a58ab9416 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -23,22 +23,27 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index e38ef8855..b51c60bfd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -23,15 +23,21 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, @@ -39,7 +45,10 @@ const VariableInfo VARIABLE_INFO[] = { {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"i_Stim", "microA_per_cm2", "membrane", EXTERNAL}, {"beta_n", "per_millisecond", "potassium_channel_n_gate", EXTERNAL} }; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index 8ae5a3e5d..5fb0b0dbc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -31,7 +31,10 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 98ab308f3..715e2a036 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -25,22 +25,27 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, @@ -48,7 +53,10 @@ class VariableType(Enum): {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL}, {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 91f595dd0..c27fbd144 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -23,11 +23,17 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, @@ -39,7 +45,10 @@ const VariableInfo VARIABLE_INFO[] = { {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"E_R", "millivolt", "membrane", EXTERNAL}, {"E_K", "millivolt", "potassium_channel", EXTERNAL} }; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index 8ae5a3e5d..5fb0b0dbc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -31,7 +31,10 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 7785dba58..4bd387526 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -25,18 +25,23 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, @@ -48,7 +53,10 @@ class VariableType(Enum): {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 3193041ba..125ae8722 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -23,13 +23,19 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"E_R", "millivolt", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, @@ -39,7 +45,10 @@ const VariableInfo VARIABLE_INFO[] = { {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"Cm", "microF_per_cm2", "membrane", EXTERNAL}, {"g_Na", "milliS_per_cm2", "sodium_channel", EXTERNAL} }; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index 8ae5a3e5d..5fb0b0dbc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -31,7 +31,10 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 49f7f8bcb..78a627ae1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -25,20 +25,25 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, @@ -48,7 +53,10 @@ class VariableType(Enum): {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index a36578b7b..f8caa7651 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -21,15 +21,21 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, @@ -39,7 +45,10 @@ const VariableInfo VARIABLE_INFO[] = { {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"V", "millivolt", "membrane", EXTERNAL}, {"m", "dimensionless", "sodium_channel_m_gate", EXTERNAL} }; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index 8ae5a3e5d..5fb0b0dbc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -31,7 +31,10 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 10b92a843..6d926cf22 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -25,20 +25,25 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, +STATE_INFO = {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, @@ -48,7 +53,10 @@ class VariableType(Enum): {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 3cb02dcd1..c3b86c0a3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -22,15 +22,21 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, @@ -38,7 +44,10 @@ const VariableInfo VARIABLE_INFO[] = { {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"V", "millivolt", "membrane", EXTERNAL}, {"i_Na", "microA_per_cm2", "sodium_channel", EXTERNAL}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", EXTERNAL} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index 8ae5a3e5d..5fb0b0dbc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -31,7 +31,10 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 1f15be90f..8ec0625ce 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -25,21 +25,26 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, +STATE_INFO = {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, @@ -47,7 +52,10 @@ class VariableType(Enum): {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.EXTERNAL}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.EXTERNAL} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index 2379ada7d..7a76b71af 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index de38477e3..6f1ab2d37 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -23,22 +23,27 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index a1ec41db7..2492a86c0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -22,15 +22,21 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"E_R", "millivolt", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT}, + {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT}, + {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, @@ -40,7 +46,10 @@ const VariableInfo VARIABLE_INFO[] = { {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"m", "dimensionless", "sodium_channel_m_gate", EXTERNAL} }; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index 8ae5a3e5d..5fb0b0dbc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -31,7 +31,10 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 2ed93ed11..40c52077b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -25,21 +25,26 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, @@ -49,7 +54,10 @@ class VariableType(Enum): {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 01b9013b6..796622169 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -22,12 +22,18 @@ const VariableInfo STATE_INFO[] = { {"n", "dimensionless", "potassium_channel_n_gate", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"Cm", "microF_per_cm2", "membrane", CONSTANT}, {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, {"E_L", "millivolt", "leakage_current", CONSTANT}, {"g_Na_max", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", CONSTANT}, + {"E_Na", "millivolt", "sodium_channel", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, {"i_Leak", "microA_per_cm2", "leakage_current", ALGEBRAIC}, {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index a4c365da2..76e98a854 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 4eb81b090..7a19fb3e3 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -23,19 +23,24 @@ class VariableType(Enum): VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.CONSTANT}, {"name": "g_Na_max", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.CONSTANT}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, {"name": "i_Leak", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 1eadd4672..1aee953d6 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -19,10 +19,16 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_ode", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"a", "per_s", "my_ode", COMPUTED_CONSTANT} }; +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createStatesArray() { double *res = (double *) malloc(STATE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index 3f1fb63fd..35acb1470 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 6de2a7b40..a0eefbb10 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -23,14 +23,19 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} + + +CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +COMPUTED_CONSTANT_INFO = [ {"name": "a", "units": "per_s", "component": "my_ode", "type": VariableType.COMPUTED_CONSTANT} ] +ALGEBRAIC_INFO = [ +] + def create_states_array(): return [nan]*STATE_COUNT diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 35629691c..5917645d3 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -19,10 +19,16 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_component", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"a", "per_s", "my_component", COMPUTED_CONSTANT} }; +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createStatesArray() { double *res = (double *) malloc(STATE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index ca79cc5f2..ec1099767 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 48b38de07..694094710 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -23,14 +23,19 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} + + +CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +COMPUTED_CONSTANT_INFO = [ {"name": "a", "units": "per_s", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} ] +ALGEBRAIC_INFO = [ +] + def create_states_array(): return [nan]*STATE_COUNT diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index 7324a50b7..900882221 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -19,10 +19,16 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_ode", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"a", "per_s", "my_ode", CONSTANT} }; +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createStatesArray() { double *res = (double *) malloc(STATE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index 3f1fb63fd..35acb1470 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 913f34ea2..183abb260 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -23,14 +23,19 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} -] +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} + -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "a", "units": "per_s", "component": "my_ode", "type": VariableType.CONSTANT} ] +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ +] + def create_states_array(): return [nan]*STATE_COUNT diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index 2e3fe1c55..c982a3aa0 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -19,10 +19,16 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_component", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"a", "per_s", "my_component", CONSTANT} }; +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createStatesArray() { double *res = (double *) malloc(STATE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index ca79cc5f2..ec1099767 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 65e03adfd..7fe189c7a 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -23,14 +23,19 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} -] +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} + -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "a", "units": "per_s", "component": "my_component", "type": VariableType.CONSTANT} ] +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ +] + def create_states_array(): return [nan]*STATE_COUNT diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index 71e7ea5a8..d1981b036 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -19,7 +19,13 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_ode", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { }; double * createStatesArray() diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index 3f1fb63fd..35acb1470 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index bc525feb5..1b1b18f96 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -23,11 +23,16 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +ALGEBRAIC_INFO = [ ] diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index a37c8889b..e299805f4 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -19,7 +19,13 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_component", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { }; double * createStatesArray() diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index ca79cc5f2..ec1099767 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index 22311d1da..81899058c 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -23,11 +23,16 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +ALGEBRAIC_INFO = [ ] diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index d8bbbf62a..c43f947e7 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -20,10 +20,16 @@ const VariableInfo STATE_INFO[] = { {"y", "dimensionless", "my_y_ode", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"epsilon", "dimensionless", "my_y_ode", CONSTANT} }; +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createStatesArray() { double *res = (double *) malloc(STATE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index cc74aaa0b..82e013544 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index a6af28cef..6edcb43f7 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -23,15 +23,20 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_x_ode", "type": VariableType.STATE}, +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_x_ode", "type": VariableType.STATE}, {"name": "y", "units": "dimensionless", "component": "my_y_ode", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "epsilon", "units": "dimensionless", "component": "my_y_ode", "type": VariableType.CONSTANT} ] +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ +] + def create_states_array(): return [nan]*STATE_COUNT diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 9ce2fe018..9e5d0e295 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -20,10 +20,16 @@ const VariableInfo STATE_INFO[] = { {"y", "dimensionless", "my_component", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"epsilon", "dimensionless", "my_component", CONSTANT} }; +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createStatesArray() { double *res = (double *) malloc(STATE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index f0d48d38d..021fc3521 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index faa79d322..adbe50fe7 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -23,15 +23,20 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE}, +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE}, {"name": "y", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "epsilon", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT} ] +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ +] + def create_states_array(): return [nan]*STATE_COUNT diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 82e57fc2d..4caef9231 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -20,10 +20,16 @@ const VariableInfo STATE_INFO[] = { {"x", "dimensionless", "my_second_ode", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"a", "per_s", "my_second_ode", CONSTANT} }; +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createStatesArray() { double *res = (double *) malloc(STATE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index 0b0953abe..41b1e7be5 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 2a5ff0d6c..d23db4467 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -23,15 +23,20 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_first_ode", "type": VariableType.STATE}, +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_first_ode", "type": VariableType.STATE}, {"name": "x", "units": "dimensionless", "component": "my_second_ode", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "a", "units": "per_s", "component": "my_second_ode", "type": VariableType.CONSTANT} ] +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ +] + def create_states_array(): return [nan]*STATE_COUNT diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index 0b29e548b..ab500425b 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -20,7 +20,13 @@ const VariableInfo STATE_INFO[] = { {"y", "dimensionless", "my_ode", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { }; double * createStatesArray() diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index 3f1fb63fd..35acb1470 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 2f19ddc26..f7b81c3c3 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -23,12 +23,17 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE}, +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE}, {"name": "y", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} + + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ ] -VARIABLE_INFO = [ +ALGEBRAIC_INFO = [ ] diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 81baaa83c..01a0c5db8 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -20,10 +20,16 @@ const VariableInfo STATE_INFO[] = { {"y2", "dimensionless", "main", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"k1", "dimensionless", "main", CONSTANT}, {"k3", "dimensionless", "main", CONSTANT}, - {"k2", "dimensionless", "main", CONSTANT}, + {"k2", "dimensionless", "main", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"y3", "dimensionless", "main", ALGEBRAIC}, {"y2_scaled", "dimensionless", "main", ALGEBRAIC} }; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index bca2cef3a..f41a8e9e9 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 8a4f383de..41f161a81 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -23,15 +23,20 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "y1", "units": "dimensionless", "component": "main", "type": VariableType.STATE}, +STATE_INFO = {"name": "y1", "units": "dimensionless", "component": "main", "type": VariableType.STATE}, {"name": "y2", "units": "dimensionless", "component": "main", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "k1", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, {"name": "k3", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, - {"name": "k2", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, + {"name": "k2", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ {"name": "y3", "units": "dimensionless", "component": "main", "type": VariableType.ALGEBRAIC}, {"name": "y2_scaled", "units": "dimensionless", "component": "main", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 7bbd363e0..fef5b5c53 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -21,10 +21,16 @@ const VariableInfo STATE_INFO[] = { {"y2", "dimensionless", "main", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"k1", "dimensionless", "main", CONSTANT}, {"k3", "dimensionless", "main", CONSTANT}, - {"k2", "dimensionless", "main", CONSTANT}, + {"k2", "dimensionless", "main", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"y2_scaled", "dimensionless", "main", ALGEBRAIC} }; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index bca2cef3a..f41a8e9e9 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 2aaab1f03..832cb289d 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -23,16 +23,21 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "y1", "units": "dimensionless", "component": "main", "type": VariableType.STATE}, +STATE_INFO = {"name": "y1", "units": "dimensionless", "component": "main", "type": VariableType.STATE}, {"name": "y3", "units": "dimensionless", "component": "main", "type": VariableType.STATE}, {"name": "y2", "units": "dimensionless", "component": "main", "type": VariableType.STATE} -] -VARIABLE_INFO = [ + +CONSTANT_INFO = [ {"name": "k1", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, {"name": "k3", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, - {"name": "k2", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, + {"name": "k2", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ {"name": "y2_scaled", "units": "dimensionless", "component": "main", "type": VariableType.ALGEBRAIC} ] diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 0c1602c01..ddc2826b8 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -19,14 +19,20 @@ const VariableInfo STATE_INFO[] = { {"sin", "dimensionless", "deriv_approx_sin", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"deriv_approx_initial_value", "dimensionless", "main", CONSTANT}, - {"C", "dimensionless", "main", CONSTANT}, + {"C", "dimensionless", "main", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"k2_oPi", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, {"k2Pi", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, {"kPi_2", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, {"kPi", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, - {"kPi_32", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, + {"kPi_32", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { {"sin", "dimensionless", "actual_sin", ALGEBRAIC}, {"sin", "dimensionless", "parabolic_approx_sin", ALGEBRAIC}, {"z", "dimensionless", "parabolic_approx_sin", ALGEBRAIC} diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index 93c965f33..fa49280dc 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 8119f9805..ed86aa9c5 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -23,18 +23,23 @@ class VariableType(Enum): VOI_INFO = {"name": "x", "units": "dimensionless", "component": "main", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "sin", "units": "dimensionless", "component": "deriv_approx_sin", "type": VariableType.STATE} -] +STATE_INFO = {"name": "sin", "units": "dimensionless", "component": "deriv_approx_sin", "type": VariableType.STATE} + -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "deriv_approx_initial_value", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, - {"name": "C", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, + {"name": "C", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ {"name": "k2_oPi", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, {"name": "k2Pi", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, {"name": "kPi_2", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, {"name": "kPi", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "kPi_32", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, + {"name": "kPi_32", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT} +] + +ALGEBRAIC_INFO = [ {"name": "sin", "units": "dimensionless", "component": "actual_sin", "type": VariableType.ALGEBRAIC}, {"name": "sin", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.ALGEBRAIC}, {"name": "z", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.ALGEBRAIC} diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 9a6fb704d..8fb19598c 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -13,7 +13,7 @@ const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; const size_t EXTERNAL_COUNT = 1; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"E", "fmol", "SLC_template3_ss", CONSTANT}, {"P_0", "per_fmol_sec4", "SLC_template3_ss", CONSTANT}, {"q_Ao", "fmol", "SLC_template3_ss", CONSTANT}, @@ -21,8 +21,17 @@ const VariableInfo VARIABLE_INFO[] = { {"q_Ai", "fmol", "SLC_template3_ss", CONSTANT}, {"P_2", "per_fmol_sec3", "SLC_template3_ss", CONSTANT}, {"P_5", "per_sec3", "SLC_template3_ss", CONSTANT}, - {"P_4", "per_fmol2_sec3", "SLC_template3_ss", CONSTANT}, - {"v", "fmol_per_sec", "SLC_template3_ss", ALGEBRAIC}, + {"P_4", "per_fmol2_sec3", "SLC_template3_ss", CONSTANT} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { + {"v", "fmol_per_sec", "SLC_template3_ss", ALGEBRAIC} +}; + +const VariableInfo EXTERNAL_INFO[] = { {"P_3", "per_fmol_sec3", "SLC_template3_ss", EXTERNAL} }; diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 92576c047..19a59cbdf 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -26,7 +26,10 @@ typedef struct { VariableType type; } VariableInfo; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createVariablesArray(); void deleteArray(double *array); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 67a0315a5..f0888ac18 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -20,7 +20,7 @@ class VariableType(Enum): EXTERNAL = 3 -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "E", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "q_Ao", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, @@ -28,8 +28,17 @@ class VariableType(Enum): {"name": "q_Ai", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_2", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "v", "units": "fmol_per_sec", "component": "SLC_template3_ss", "type": VariableType.ALGEBRAIC}, + {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ + {"name": "v", "units": "fmol_per_sec", "component": "SLC_template3_ss", "type": VariableType.ALGEBRAIC} +] + +EXTERNAL_INFO = [ {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.EXTERNAL} ] diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index bf4de6ab2..eecc37c61 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -19,10 +19,16 @@ const VariableInfo STATE_INFO[] = { {"X", "dimensionless", "component_1", STATE} }; -const VariableInfo VARIABLE_INFO[] = { +const VariableInfo CONSTANT_INFO[] = { {"X_init", "dimensionless", "component_2", CONSTANT} }; +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { +}; + double * createStatesArray() { double *res = (double *) malloc(STATE_COUNT*sizeof(double)); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index 340f578dd..0db53022c 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -29,7 +29,9 @@ typedef struct { extern const VariableInfo VOI_INFO; extern const VariableInfo STATE_INFO[]; -extern const VariableInfo VARIABLE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createVariablesArray(); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 491332bdf..a2dd6a166 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -23,14 +23,19 @@ class VariableType(Enum): VOI_INFO = {"name": "t", "units": "second", "component": "component_1", "type": VariableType.VARIABLE_OF_INTEGRATION} -STATE_INFO = [ - {"name": "X", "units": "dimensionless", "component": "component_1", "type": VariableType.STATE} -] +STATE_INFO = {"name": "X", "units": "dimensionless", "component": "component_1", "type": VariableType.STATE} + -VARIABLE_INFO = [ +CONSTANT_INFO = [ {"name": "X_init", "units": "dimensionless", "component": "component_2", "type": VariableType.CONSTANT} ] +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ +] + def create_states_array(): return [nan]*STATE_COUNT From 4bc05e88837ca1292337d6e39c0f53f2aecf5b5d Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 14 Aug 2024 15:06:36 +0200 Subject: [PATCH 20/74] Generator: don't need to mention the type of a variable in a XXX_INFO array anymore. --- src/api/libcellml/generatorprofile.h | 166 ------ src/bindings/interface/generatorprofile.i | 42 -- src/bindings/javascript/generatorprofile.cpp | 14 - src/generator.cpp | 50 +- src/generator_p.h | 7 +- src/generatorprofile.cpp | 186 +------ src/generatorprofilesha1values.h | 4 +- src/generatorprofiletools.cpp | 12 - .../javascript/generatorprofile.test.js | 48 -- .../bindings/python/test_generator_profile.py | 87 +-- tests/coverage/coverage.cpp | 50 -- tests/generator/generatorprofile.cpp | 65 +-- tests/resources/coverage/generator/model.c | 422 +++++++------- tests/resources/coverage/generator/model.h | 9 - .../generator/model.modified.profile.c | 422 +++++++------- .../generator/model.modified.profile.h | 9 - .../generator/model.modified.profile.py | 431 +++++++-------- tests/resources/coverage/generator/model.py | 431 +++++++-------- .../algebraic_eqn_computed_var_on_rhs/model.c | 4 +- .../model.external.c | 4 +- .../model.external.h | 8 - .../model.external.py | 12 +- .../algebraic_eqn_computed_var_on_rhs/model.h | 7 - .../model.py | 11 +- .../algebraic_eqn_const_var_on_rhs/model.c | 4 +- .../algebraic_eqn_const_var_on_rhs/model.h | 7 - .../algebraic_eqn_const_var_on_rhs/model.py | 11 +- .../algebraic_eqn_constant_on_rhs/model.c | 2 +- .../algebraic_eqn_constant_on_rhs/model.h | 7 - .../algebraic_eqn_constant_on_rhs/model.py | 9 +- .../algebraic_eqn_derivative_on_rhs/model.c | 8 +- .../algebraic_eqn_derivative_on_rhs/model.h | 9 - .../algebraic_eqn_derivative_on_rhs/model.py | 17 +- .../model.c | 8 +- .../model.h | 9 - .../model.py | 17 +- .../algebraic_eqn_state_var_on_rhs/model.c | 8 +- .../algebraic_eqn_state_var_on_rhs/model.h | 9 - .../algebraic_eqn_state_var_on_rhs/model.py | 17 +- .../model.c | 8 +- .../model.h | 9 - .../model.py | 17 +- .../model.c | 8 +- .../model.external.c | 8 +- .../model.external.h | 8 - .../model.external.py | 16 +- .../model.h | 7 - .../model.py | 15 +- .../model.c | 6 +- .../model.h | 7 - .../model.py | 13 +- .../model.three.externals.c | 6 +- .../model.three.externals.h | 8 - .../model.three.externals.py | 14 +- .../model.not.ordered.c | 12 +- .../model.not.ordered.h | 7 - .../model.not.ordered.py | 19 +- .../model.ordered.c | 12 +- .../model.ordered.h | 7 - .../model.ordered.py | 19 +- .../algebraic_unknown_var_on_rhs/model.c | 4 +- .../algebraic_unknown_var_on_rhs/model.h | 7 - .../algebraic_unknown_var_on_rhs/model.py | 11 +- .../generator/cell_geometry_model/model.c | 8 +- .../cell_geometry_model/model.external.c | 8 +- .../cell_geometry_model/model.external.h | 8 - .../cell_geometry_model/model.external.py | 16 +- .../generator/cell_geometry_model/model.h | 7 - .../generator/cell_geometry_model/model.py | 15 +- .../model.c | 10 +- .../model.h | 9 - .../model.py | 19 +- .../generator/cellml_slc_example/model.py | 27 +- .../model.c | 6 +- .../model.h | 9 - .../model.py | 15 +- .../cellml_unit_scaling_constant/model.c | 6 +- .../cellml_unit_scaling_constant/model.h | 7 - .../cellml_unit_scaling_constant/model.py | 13 +- .../cellml_unit_scaling_rate/model.c | 8 +- .../cellml_unit_scaling_rate/model.h | 9 - .../cellml_unit_scaling_rate/model.py | 17 +- .../cellml_unit_scaling_state/model.c | 8 +- .../cellml_unit_scaling_state/model.h | 9 - .../cellml_unit_scaling_state/model.py | 17 +- .../model.c | 6 +- .../model.h | 9 - .../model.py | 15 +- .../model.c | 10 +- .../model.h | 9 - .../model.py | 19 +- .../cellml_unit_scaling_voi_direct/model.c | 6 +- .../cellml_unit_scaling_voi_direct/model.h | 9 - .../cellml_unit_scaling_voi_direct/model.py | 15 +- .../cellml_unit_scaling_voi_indirect/model.c | 8 +- .../cellml_unit_scaling_voi_indirect/model.h | 9 - .../cellml_unit_scaling_voi_indirect/model.py | 17 +- .../generator/dae_cellml_1_1_model/model.c | 26 +- .../generator/dae_cellml_1_1_model/model.h | 9 - .../generator/dae_cellml_1_1_model/model.py | 35 +- .../generator/dependent_eqns/model.c | 8 +- .../generator/dependent_eqns/model.h | 9 - .../generator/dependent_eqns/model.py | 17 +- .../model.c | 502 ++++++++--------- .../model.h | 9 - .../model.py | 513 +++++++++--------- .../model.c | 402 +++++++------- .../model.h | 9 - .../model.py | 411 +++++++------- .../model.algebraic.c | 46 +- .../model.algebraic.h | 10 - .../model.algebraic.py | 56 +- .../model.c | 46 +- .../model.computed.constant.c | 46 +- .../model.computed.constant.h | 10 - .../model.computed.constant.py | 56 +- .../model.constant.c | 46 +- .../model.constant.h | 10 - .../model.constant.py | 56 +- .../model.dae.c | 46 +- .../model.dae.h | 9 - .../model.dae.py | 55 +- .../model.dependent.algebraic.c | 46 +- .../model.dependent.algebraic.h | 10 - .../model.dependent.algebraic.py | 56 +- .../model.dependent.computed.constant.c | 46 +- .../model.dependent.computed.constant.h | 10 - .../model.dependent.computed.constant.py | 56 +- .../model.dependent.constant.c | 46 +- .../model.dependent.constant.h | 10 - .../model.dependent.constant.py | 56 +- .../model.dependent.state.c | 46 +- .../model.dependent.state.h | 10 - .../model.dependent.state.py | 56 +- .../model.external.c | 46 +- .../model.external.h | 10 - .../model.external.py | 56 +- .../model.h | 9 - .../model.py | 55 +- .../model.state.c | 46 +- .../model.state.h | 10 - .../model.state.py | 56 +- .../generator/noble_model_1962/model.c | 44 +- .../generator/noble_model_1962/model.h | 9 - .../generator/noble_model_1962/model.py | 53 +- .../generator/ode_computed_var_on_rhs/model.c | 6 +- .../generator/ode_computed_var_on_rhs/model.h | 9 - .../ode_computed_var_on_rhs/model.py | 15 +- .../model.c | 6 +- .../model.h | 9 - .../model.py | 15 +- .../generator/ode_const_var_on_rhs/model.c | 6 +- .../generator/ode_const_var_on_rhs/model.h | 9 - .../generator/ode_const_var_on_rhs/model.py | 15 +- .../model.c | 6 +- .../model.h | 9 - .../model.py | 15 +- .../generator/ode_constant_on_rhs/model.c | 4 +- .../generator/ode_constant_on_rhs/model.h | 9 - .../generator/ode_constant_on_rhs/model.py | 13 +- .../ode_constant_on_rhs_one_component/model.c | 4 +- .../ode_constant_on_rhs_one_component/model.h | 9 - .../model.py | 13 +- .../ode_multiple_dependent_odes/model.c | 8 +- .../ode_multiple_dependent_odes/model.h | 9 - .../ode_multiple_dependent_odes/model.py | 17 +- .../model.c | 8 +- .../model.h | 9 - .../model.py | 17 +- .../ode_multiple_odes_with_same_name/model.c | 8 +- .../ode_multiple_odes_with_same_name/model.h | 9 - .../ode_multiple_odes_with_same_name/model.py | 17 +- .../generator/ode_unknown_var_on_rhs/model.c | 6 +- .../generator/ode_unknown_var_on_rhs/model.h | 9 - .../generator/ode_unknown_var_on_rhs/model.py | 15 +- .../robertson_model_1966/model.dae.c | 16 +- .../robertson_model_1966/model.dae.h | 9 - .../robertson_model_1966/model.dae.py | 25 +- .../robertson_model_1966/model.ode.c | 16 +- .../robertson_model_1966/model.ode.h | 9 - .../robertson_model_1966/model.ode.py | 25 +- .../generator/sine_model_imports/model.c | 24 +- .../generator/sine_model_imports/model.h | 9 - .../generator/sine_model_imports/model.py | 33 +- .../model.c | 20 +- .../model.h | 8 - .../model.py | 28 +- .../model.c | 6 +- .../model.h | 9 - .../model.py | 15 +- 190 files changed, 2692 insertions(+), 4422 deletions(-) diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index b3ee8ec27..69a00d263 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -2653,172 +2653,6 @@ class LIBCELLML_EXPORT GeneratorProfile */ void setImplementationExternalCountString(const std::string &implementationExternalCountString); - /** - * @brief Get the @c std::string for the data structure for the variable - * type object. - * - * Return the @c std::string for the data structure for the variable type - * object. - * - * @param forDifferentialModel Whether the data structure is for a - * differential model, as opposed to an algebraic model. - * @param withExternalVariables Whether the data structure is for a model - * with external variables. - * - * @return The @c std::string for the data structure for the variable type - * object. - */ - std::string variableTypeObjectString(bool forDifferentialModel, - bool withExternalVariables) const; - - /** - * @brief Set the @c std::string for the data structure for the variable - * type object. - * - * Set the @c std::string for the data structure for the variable type - * object. - * - * @sa variableTypeObjectString - * - * @param forDifferentialModel Whether the data structure is for a - * differential model, as opposed to an algebraic model. - * @param withExternalVariables Whether the data structure is for a model - * with external variables. - * @param variableTypeObjectString The @c std::string to use for the data - * structure for the variable type object. - */ - void setVariableTypeObjectString(bool forDifferentialModel, - bool withExternalVariables, - const std::string &variableTypeObjectString); - - /** - * @brief Get the @c std::string for the name of the variable of integration - * variable type. - * - * Return the @c std::string for the name of the variable of integration - * variable type that is used in a differential model. - * - * @return The @c std::string for the name of the variable of integration - * variable type. - */ - std::string variableOfIntegrationVariableTypeString() const; - - /** - * @brief Set the @c std::string for the name of the variable of integration - * variable type. - * - * Set the @c std::string for the name of the variable of integration - * variable type that is used in a differential model. - * - * @param variableOfIntegrationVariableTypeString The @c std::string to use - * for the name of the variable of integration variable type. - */ - void setVariableOfIntegrationVariableTypeString(const std::string &variableOfIntegrationVariableTypeString); - - /** - * @brief Get the @c std::string for the name of the state variable type. - * - * Return the @c std::string for the name of the state variable type that is - * used in a differential model. - * - * @return The @c std::string for the name of the state variable type. - */ - std::string stateVariableTypeString() const; - - /** - * @brief Set the @c std::string for the name of the state variable type. - * - * Set the @c std::string for the name of the state variable type that is - * used in a differential model. - * - * @param stateTypeString The @c std::string to use for the name of the - * state variable type. - */ - void setStateVariableTypeString(const std::string &stateVariableTypeString); - - /** - * @brief Get the @c std::string for the name of the constant variable type. - * - * Return the @c std::string for the name of the constant variable type. - * - * @return The @c std::string for the name of the constant variable type. - */ - std::string constantVariableTypeString() const; - - /** - * @brief Set the @c std::string for the name of the constant variable type. - * - * Set the @c std::string for the name of the constant variable type. - * - * @param constantVariableTypeString The @c std::string to use for the name of the - * constant variable type. - */ - void setConstantVariableTypeString(const std::string &constantVariableTypeString); - - /** - * @brief Get the @c std::string for the name of the computed constant - * variable type. - * - * Return the @c std::string for the name of the computed constant variable - * type. - * - * @return The @c std::string for the name of the computed constant variable - * type. - */ - std::string computedConstantVariableTypeString() const; - - /** - * @brief Set the @c std::string for the name of the computed constant - * variable type. - * - * Set the @c std::string for the name of the computed constant variable - * type. - * - * @param computedConstantVariableTypeString The @c std::string to use for the name of the - * computed constant variable type. - */ - void setComputedConstantVariableTypeString(const std::string &computedConstantVariableTypeString); - - /** - * @brief Get the @c std::string for the name of the algebraic variable - * type. - * - * Return the @c std::string for the name of the algebraic variable type. - * - * @return The @c std::string for the name of the algebraic variable type. - */ - std::string algebraicVariableTypeString() const; - - /** - * @brief Set the @c std::string for the name of the algebraic variable - * type. - * - * Set the @c std::string for the name of the algebraic variable type. - * - * @param algebraicVariableTypeString The @c std::string to use for the name of the - * algebraic variable type. - */ - void setAlgebraicVariableTypeString(const std::string &algebraicVariableTypeString); - - /** - * @brief Get the @c std::string for the name of the external variable type. - * - * Return the @c std::string for the name of the external variable type. - * - * @return The @c std::string for the name of the external variable type. - */ - std::string externalVariableTypeString() const; - - /** - * @brief Set the @c std::string for the name of the external variable type. - * - * Set this @c std::string for the name of the external variable type. - * - * @param externalVariableTypeString The @c std::string to use for the name of the - * external variable type. - */ - void setExternalVariableTypeString(const std::string &externalVariableTypeString); - /** * @brief Get the @c std::string for the data structure for the variable * information object. diff --git a/src/bindings/interface/generatorprofile.i b/src/bindings/interface/generatorprofile.i index b7e5c3cb6..712e2198a 100644 --- a/src/bindings/interface/generatorprofile.i +++ b/src/bindings/interface/generatorprofile.i @@ -729,48 +729,6 @@ the tag, which will be replaced with the number of states in t "Sets the string for the implementation of the external count constant. To be useful, the string should contain the tag, which will be replaced with the number of states in the model."; -%feature("docstring") libcellml::GeneratorProfile::variableTypeObjectString -"Returns the string for the data structure for the variable type object."; - -%feature("docstring") libcellml::GeneratorProfile::setVariableTypeObjectString -"Sets the string for the data structure for the variable type object."; - -%feature("docstring") libcellml::GeneratorProfile::variableOfIntegrationVariableTypeString -"Returns the string for the name of the variable of integration variable type."; - -%feature("docstring") libcellml::GeneratorProfile::setVariableOfIntegrationVariableTypeString -"Sets the string for the name of the variable of integration variable type."; - -%feature("docstring") libcellml::GeneratorProfile::stateVariableTypeString -"Returns the string for the name of the state variable type."; - -%feature("docstring") libcellml::GeneratorProfile::setStateVariableTypeString -"Sets the string for the name of the state variable type."; - -%feature("docstring") libcellml::GeneratorProfile::constantVariableTypeString -"Returns the string for the name of the constant variable type."; - -%feature("docstring") libcellml::GeneratorProfile::setConstantVariableTypeString -"Sets the string for the name of the constant variable type."; - -%feature("docstring") libcellml::GeneratorProfile::computedConstantVariableTypeString -"Returns the string for the name of the computed constant variable type."; - -%feature("docstring") libcellml::GeneratorProfile::setComputedConstantVariableTypeString -"Sets the string for the name of the computed constant variable type."; - -%feature("docstring") libcellml::GeneratorProfile::algebraicVariableTypeString -"Returns the string for the name of the algebraic variable type."; - -%feature("docstring") libcellml::GeneratorProfile::setAlgebraicVariableTypeString -"Sets the string for the name of the algebraic variable type."; - -%feature("docstring") libcellml::GeneratorProfile::externalVariableTypeString -"Returns the string for the name of the external variable type."; - -%feature("docstring") libcellml::GeneratorProfile::setExternalVariableTypeString -"Sets the string for the name of the external variable type."; - %feature("docstring") libcellml::GeneratorProfile::variableInfoObjectString "Returns the string for the data structure for the variable information object."; diff --git a/src/bindings/javascript/generatorprofile.cpp b/src/bindings/javascript/generatorprofile.cpp index b2fef805b..5a28e6cac 100644 --- a/src/bindings/javascript/generatorprofile.cpp +++ b/src/bindings/javascript/generatorprofile.cpp @@ -267,20 +267,6 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setInterfaceExternalCountString", &libcellml::GeneratorProfile::setInterfaceExternalCountString) .function("implementationExternalCountString", &libcellml::GeneratorProfile::implementationExternalCountString) .function("setImplementationExternalCountString", &libcellml::GeneratorProfile::setImplementationExternalCountString) - .function("variableTypeObjectString", &libcellml::GeneratorProfile::variableTypeObjectString) - .function("setVariableTypeObjectString", &libcellml::GeneratorProfile::setVariableTypeObjectString) - .function("variableOfIntegrationVariableTypeString", &libcellml::GeneratorProfile::variableOfIntegrationVariableTypeString) - .function("setVariableOfIntegrationVariableTypeString", &libcellml::GeneratorProfile::setVariableOfIntegrationVariableTypeString) - .function("stateVariableTypeString", &libcellml::GeneratorProfile::stateVariableTypeString) - .function("setStateVariableTypeString", &libcellml::GeneratorProfile::setStateVariableTypeString) - .function("constantVariableTypeString", &libcellml::GeneratorProfile::constantVariableTypeString) - .function("setConstantVariableTypeString", &libcellml::GeneratorProfile::setConstantVariableTypeString) - .function("computedConstantVariableTypeString", &libcellml::GeneratorProfile::computedConstantVariableTypeString) - .function("setComputedConstantVariableTypeString", &libcellml::GeneratorProfile::setComputedConstantVariableTypeString) - .function("algebraicVariableTypeString", &libcellml::GeneratorProfile::algebraicVariableTypeString) - .function("setAlgebraicVariableTypeString", &libcellml::GeneratorProfile::setAlgebraicVariableTypeString) - .function("externalVariableTypeString", &libcellml::GeneratorProfile::externalVariableTypeString) - .function("setExternalVariableTypeString", &libcellml::GeneratorProfile::setExternalVariableTypeString) .function("variableInfoObjectString", &libcellml::GeneratorProfile::variableInfoObjectString) .function("setVariableInfoObjectString", &libcellml::GeneratorProfile::setVariableInfoObjectString) .function("interfaceVoiInfoString", &libcellml::GeneratorProfile::interfaceVoiInfoString) diff --git a/src/generator.cpp b/src/generator.cpp index 442fc9d1a..4c7b02d81 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -361,17 +361,6 @@ void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) mCode += code; } -void Generator::GeneratorImpl::addVariableTypeObjectCode() -{ - auto variableTypeObjectString = mProfile->variableTypeObjectString(modelHasOdes(), - mModel->hasExternalVariables()); - - if (!variableTypeObjectString.empty()) { - mCode += newLineIfNeeded() - + variableTypeObjectString; - } -} - std::string Generator::GeneratorImpl::generateVariableInfoObjectCode(const std::string &objectString) const { size_t componentSize = 0; @@ -398,14 +387,12 @@ void Generator::GeneratorImpl::addVariableInfoObjectCode() std::string Generator::GeneratorImpl::generateVariableInfoEntryCode(const std::string &name, const std::string &units, - const std::string &component, - const std::string &type) const + const std::string &component) const { - return replace(replace(replace(replace(mProfile->variableInfoEntryString(), + return replace(replace(replace(mProfile->variableInfoEntryString(), "[NAME]", name), "[UNITS]", units), - "[COMPONENT]", component), - "[TYPE]", type); + "[COMPONENT]", component); } void Generator::GeneratorImpl::addInterfaceVariableInfoCode() @@ -447,13 +434,11 @@ void Generator::GeneratorImpl::addInterfaceVariableInfoCode() } void Generator::GeneratorImpl::doAddImplementationVariableInfoCode(const std::string &variableInfoString, - const std::string &variableTypeString, const std::vector &variables, bool voiVariable) { if (!variableInfoString.empty() && !mProfile->variableInfoEntryString().empty() - && !variableTypeString.empty() && !mProfile->arrayElementSeparatorString().empty()) { std::string infoElementsCode; @@ -467,8 +452,7 @@ void Generator::GeneratorImpl::doAddImplementationVariableInfoCode(const std::st infoElementsCode += (voiVariable ? "" : mProfile->indentString()) + generateVariableInfoEntryCode(variableVariable->name(), variableVariable->units()->name(), - owningComponent(variableVariable)->name(), - variableTypeString); + owningComponent(variableVariable)->name()); } if (!voiVariable && !infoElementsCode.empty()) { @@ -487,33 +471,21 @@ void Generator::GeneratorImpl::addImplementationVariableInfoCode() variables.push_back(mModel->voi()); - doAddImplementationVariableInfoCode(mProfile->implementationVoiInfoString(), - mProfile->variableOfIntegrationVariableTypeString(), - variables, true); + doAddImplementationVariableInfoCode(mProfile->implementationVoiInfoString(), variables, true); } if (modelHasOdes()) { - doAddImplementationVariableInfoCode(mProfile->implementationStateInfoString(), - mProfile->stateVariableTypeString(), - mModel->states(), false); + doAddImplementationVariableInfoCode(mProfile->implementationStateInfoString(), mModel->states(), false); } - doAddImplementationVariableInfoCode(mProfile->implementationConstantInfoString(), - mProfile->constantVariableTypeString(), - mModel->constants(), false); + doAddImplementationVariableInfoCode(mProfile->implementationConstantInfoString(), mModel->constants(), false); - doAddImplementationVariableInfoCode(mProfile->implementationComputedConstantInfoString(), - mProfile->computedConstantVariableTypeString(), - mModel->computedConstants(), false); + doAddImplementationVariableInfoCode(mProfile->implementationComputedConstantInfoString(), mModel->computedConstants(), false); - doAddImplementationVariableInfoCode(mProfile->implementationAlgebraicInfoString(), - mProfile->algebraicVariableTypeString(), - mModel->algebraic(), false); + doAddImplementationVariableInfoCode(mProfile->implementationAlgebraicInfoString(), mModel->algebraic(), false); if (mModel->hasExternalVariables()) { - doAddImplementationVariableInfoCode(mProfile->implementationExternalInfoString(), - mProfile->externalVariableTypeString(), - mModel->externals(), false); + doAddImplementationVariableInfoCode(mProfile->implementationExternalInfoString(), mModel->externals(), false); } } @@ -2025,7 +1997,6 @@ std::string Generator::interfaceCode() const // Add code for the variable information related objects. - mPimpl->addVariableTypeObjectCode(); mPimpl->addVariableInfoObjectCode(); // Add code for the interface of the information about the variable of integration, states, constants, computed @@ -2080,7 +2051,6 @@ std::string Generator::implementationCode() const // Add code for the variable information related objects. if (!mPimpl->mProfile->hasInterface()) { - mPimpl->addVariableTypeObjectCode(); mPimpl->addVariableInfoObjectCode(); } diff --git a/src/generator_p.h b/src/generator_p.h index fd79ffbff..02c6fdf5a 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -82,20 +82,17 @@ struct Generator::GeneratorImpl void addStateAndVariableCountCode(bool interface = false); - void addVariableTypeObjectCode(); - std::string generateVariableInfoObjectCode(const std::string &objectString) const; void addVariableInfoObjectCode(); std::string generateVariableInfoEntryCode(const std::string &name, const std::string &units, - const std::string &component, - const std::string &type) const; + const std::string &component) const; void addInterfaceVariableInfoCode(); - void doAddImplementationVariableInfoCode(const std::string &variableInfoString, const std::string &variableTypeString, + void doAddImplementationVariableInfoCode(const std::string &variableInfoString, const std::vector &variables, bool voiVariable); void addImplementationVariableInfoCode(); diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 4258948d4..843249297 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -196,18 +196,6 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mInterfaceExternalCountString; std::string mImplementationExternalCountString; - std::string mVariableTypeObjectFamWoevString; - std::string mVariableTypeObjectFamWevString; - std::string mVariableTypeObjectFdmWoevString; - std::string mVariableTypeObjectFdmWevString; - - std::string mVariableOfIntegrationVariableTypeString; - std::string mStateVariableTypeString; - std::string mConstantVariableTypeString; - std::string mComputedConstantVariableTypeString; - std::string mAlgebraicVariableTypeString; - std::string mExternalVariableTypeString; - std::string mVariableInfoObjectString; std::string mInterfaceVoiInfoString; @@ -537,45 +525,10 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceExternalCountString = "extern const size_t EXTERNAL_COUNT;\n"; mImplementationExternalCountString = "const size_t EXTERNAL_COUNT = [EXTERNAL_COUNT];\n"; - mVariableTypeObjectFamWoevString = "typedef enum {\n" - " CONSTANT,\n" - " COMPUTED_CONSTANT,\n" - " ALGEBRAIC\n" - "} VariableType;\n"; - mVariableTypeObjectFamWevString = "typedef enum {\n" - " CONSTANT,\n" - " COMPUTED_CONSTANT,\n" - " ALGEBRAIC,\n" - " EXTERNAL\n" - "} VariableType;\n"; - mVariableTypeObjectFdmWoevString = "typedef enum {\n" - " VARIABLE_OF_INTEGRATION,\n" - " STATE,\n" - " CONSTANT,\n" - " COMPUTED_CONSTANT,\n" - " ALGEBRAIC\n" - "} VariableType;\n"; - mVariableTypeObjectFdmWevString = "typedef enum {\n" - " VARIABLE_OF_INTEGRATION,\n" - " STATE,\n" - " CONSTANT,\n" - " COMPUTED_CONSTANT,\n" - " ALGEBRAIC,\n" - " EXTERNAL\n" - "} VariableType;\n"; - - mVariableOfIntegrationVariableTypeString = "VARIABLE_OF_INTEGRATION"; - mStateVariableTypeString = "STATE"; - mConstantVariableTypeString = "CONSTANT"; - mComputedConstantVariableTypeString = "COMPUTED_CONSTANT"; - mAlgebraicVariableTypeString = "ALGEBRAIC"; - mExternalVariableTypeString = "EXTERNAL"; - mVariableInfoObjectString = "typedef struct {\n" " char name[[NAME_SIZE]];\n" " char units[[UNITS_SIZE]];\n" " char component[[COMPONENT_SIZE]];\n" - " VariableType type;\n" "} VariableInfo;\n"; mInterfaceVoiInfoString = "extern const VariableInfo VOI_INFO;\n"; @@ -606,7 +559,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "};\n"; - mVariableInfoEntryString = "{\"[NAME]\", \"[UNITS]\", \"[COMPONENT]\", [TYPE]}"; + mVariableInfoEntryString = "{\"[NAME]\", \"[UNITS]\", \"[COMPONENT]\"}"; mVoiString = "voi"; @@ -992,44 +945,6 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceExternalCountString = ""; mImplementationExternalCountString = "EXTERNAL_COUNT = [EXTERNAL_COUNT]\n"; - mVariableTypeObjectFamWoevString = "\n" - "class VariableType(Enum):\n" - " CONSTANT = 0\n" - " COMPUTED_CONSTANT = 1\n" - " ALGEBRAIC = 2\n" - "\n"; - mVariableTypeObjectFamWevString = "\n" - "class VariableType(Enum):\n" - " CONSTANT = 0\n" - " COMPUTED_CONSTANT = 1\n" - " ALGEBRAIC = 2\n" - " EXTERNAL = 3\n" - "\n"; - mVariableTypeObjectFdmWoevString = "\n" - "class VariableType(Enum):\n" - " VARIABLE_OF_INTEGRATION = 0\n" - " STATE = 1\n" - " CONSTANT = 2\n" - " COMPUTED_CONSTANT = 3\n" - " ALGEBRAIC = 4\n" - "\n"; - mVariableTypeObjectFdmWevString = "\n" - "class VariableType(Enum):\n" - " VARIABLE_OF_INTEGRATION = 0\n" - " STATE = 1\n" - " CONSTANT = 2\n" - " COMPUTED_CONSTANT = 3\n" - " ALGEBRAIC = 4\n" - " EXTERNAL = 5\n" - "\n"; - - mVariableOfIntegrationVariableTypeString = "VariableType.VARIABLE_OF_INTEGRATION"; - mStateVariableTypeString = "VariableType.STATE"; - mConstantVariableTypeString = "VariableType.CONSTANT"; - mComputedConstantVariableTypeString = "VariableType.COMPUTED_CONSTANT"; - mAlgebraicVariableTypeString = "VariableType.ALGEBRAIC"; - mExternalVariableTypeString = "VariableType.EXTERNAL"; - mVariableInfoObjectString = ""; mInterfaceVoiInfoString = ""; @@ -1058,7 +973,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "]\n"; - mVariableInfoEntryString = "{\"name\": \"[NAME]\", \"units\": \"[UNITS]\", \"component\": \"[COMPONENT]\", \"type\": [TYPE]}"; + mVariableInfoEntryString = "{\"name\": \"[NAME]\", \"units\": \"[UNITS]\", \"component\": \"[COMPONENT]\"}"; mVoiString = "voi"; @@ -2400,103 +2315,6 @@ void GeneratorProfile::setImplementationExternalCountString(const std::string &i mPimpl->mImplementationExternalCountString = implementationExternalCountString; } -std::string GeneratorProfile::variableTypeObjectString(bool forDifferentialModel, - bool withExternalVariables) const -{ - if (forDifferentialModel) { - if (withExternalVariables) { - return mPimpl->mVariableTypeObjectFdmWevString; - } - - return mPimpl->mVariableTypeObjectFdmWoevString; - } - - if (withExternalVariables) { - return mPimpl->mVariableTypeObjectFamWevString; - } - - return mPimpl->mVariableTypeObjectFamWoevString; -} - -void GeneratorProfile::setVariableTypeObjectString(bool forDifferentialModel, - bool withExternalVariables, - const std::string &variableTypeObjectString) -{ - if (forDifferentialModel) { - if (withExternalVariables) { - mPimpl->mVariableTypeObjectFdmWevString = variableTypeObjectString; - } else { - mPimpl->mVariableTypeObjectFdmWoevString = variableTypeObjectString; - } - } else { - if (withExternalVariables) { - mPimpl->mVariableTypeObjectFamWevString = variableTypeObjectString; - } else { - mPimpl->mVariableTypeObjectFamWoevString = variableTypeObjectString; - } - } -} - -std::string GeneratorProfile::variableOfIntegrationVariableTypeString() const -{ - return mPimpl->mVariableOfIntegrationVariableTypeString; -} - -void GeneratorProfile::setVariableOfIntegrationVariableTypeString(const std::string &variableOfIntegrationVariableTypeString) -{ - mPimpl->mVariableOfIntegrationVariableTypeString = variableOfIntegrationVariableTypeString; -} - -std::string GeneratorProfile::stateVariableTypeString() const -{ - return mPimpl->mStateVariableTypeString; -} - -void GeneratorProfile::setStateVariableTypeString(const std::string &stateVariableTypeString) -{ - mPimpl->mStateVariableTypeString = stateVariableTypeString; -} - -std::string GeneratorProfile::constantVariableTypeString() const -{ - return mPimpl->mConstantVariableTypeString; -} - -void GeneratorProfile::setConstantVariableTypeString(const std::string &constantVariableTypeString) -{ - mPimpl->mConstantVariableTypeString = constantVariableTypeString; -} - -std::string GeneratorProfile::computedConstantVariableTypeString() const -{ - return mPimpl->mComputedConstantVariableTypeString; -} - -void GeneratorProfile::setComputedConstantVariableTypeString(const std::string &computedConstantVariableTypeString) -{ - mPimpl->mComputedConstantVariableTypeString = computedConstantVariableTypeString; -} - -std::string GeneratorProfile::algebraicVariableTypeString() const -{ - return mPimpl->mAlgebraicVariableTypeString; -} - -void GeneratorProfile::setAlgebraicVariableTypeString(const std::string &algebraicVariableTypeString) -{ - mPimpl->mAlgebraicVariableTypeString = algebraicVariableTypeString; -} - -std::string GeneratorProfile::externalVariableTypeString() const -{ - return mPimpl->mExternalVariableTypeString; -} - -void GeneratorProfile::setExternalVariableTypeString(const std::string &externalVariableTypeString) -{ - mPimpl->mExternalVariableTypeString = externalVariableTypeString; -} - std::string GeneratorProfile::variableInfoObjectString() const { return mPimpl->mVariableInfoObjectString; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 5db086202..577df6a27 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "51c71d6a06d1b6e38467cc3f333062d5be98fba1"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "710333a658fecca12a9ff0c6bf41dd45a12c0f35"; +static const char C_GENERATOR_PROFILE_SHA1[] = "14c2693a5338e70419f230e375f49acef40a68ce"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "23ed0dcff0e9015280889861f4d75420fd14c211"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index f798af19d..9891778ce 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -454,18 +454,6 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->interfaceExternalCountString() + generatorProfile->implementationExternalCountString(); - profileContents += generatorProfile->variableTypeObjectString(false, false); - profileContents += generatorProfile->variableTypeObjectString(false, true); - profileContents += generatorProfile->variableTypeObjectString(true, false); - profileContents += generatorProfile->variableTypeObjectString(true, true); - - profileContents += generatorProfile->variableOfIntegrationVariableTypeString() - + generatorProfile->stateVariableTypeString() - + generatorProfile->constantVariableTypeString() - + generatorProfile->computedConstantVariableTypeString() - + generatorProfile->algebraicVariableTypeString() - + generatorProfile->externalVariableTypeString(); - profileContents += generatorProfile->variableInfoObjectString(); profileContents += generatorProfile->interfaceVoiInfoString() diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index 095d28052..6aa7460ee 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -732,54 +732,6 @@ describe("GeneratorProfile tests", () => { x.setImplementationExternalCountString("something") expect(x.implementationExternalCountString()).toBe("something") }); - test("Checking GeneratorProfile.variableTypeObjectString.", () => { - const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - - x.setVariableTypeObjectString(false, false, "something") - expect(x.variableTypeObjectString(false, false)).toBe("something") - x.setVariableTypeObjectString(false, true, "something") - expect(x.variableTypeObjectString(false, true)).toBe("something") - x.setVariableTypeObjectString(true, false, "something") - expect(x.variableTypeObjectString(true, false)).toBe("something") - x.setVariableTypeObjectString(true, true, "something") - expect(x.variableTypeObjectString(true, true)).toBe("something") - }); - test("Checking GeneratorProfile.variableOfIntegrationVariableTypeString.", () => { - const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - - x.setVariableOfIntegrationVariableTypeString("something") - expect(x.variableOfIntegrationVariableTypeString()).toBe("something") - }); - test("Checking GeneratorProfile.stateVariableTypeString.", () => { - const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - - x.setStateVariableTypeString("something") - expect(x.stateVariableTypeString()).toBe("something") - }); - test("Checking GeneratorProfile.constantVariableTypeString.", () => { - const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - - x.setConstantVariableTypeString("something") - expect(x.constantVariableTypeString()).toBe("something") - }); - test("Checking GeneratorProfile.computedConstantVariableTypeString.", () => { - const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - - x.setComputedConstantVariableTypeString("something") - expect(x.computedConstantVariableTypeString()).toBe("something") - }); - test("Checking GeneratorProfile.algebraicVariableTypeString.", () => { - const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - - x.setAlgebraicVariableTypeString("something") - expect(x.algebraicVariableTypeString()).toBe("something") - }); - test("Checking GeneratorProfile.externalVariableTypeString.", () => { - const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - - x.setExternalVariableTypeString("something") - expect(x.externalVariableTypeString()).toBe("something") - }); test("Checking GeneratorProfile.variableInfoObjectString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index ce31fc92c..cf532b8a6 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -214,24 +214,6 @@ def test_acsch_string(self): g.setAcschString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.acschString()) - def test_algebraic_variable_type_string(self): - from libcellml import GeneratorProfile - - g = GeneratorProfile() - - self.assertEqual('ALGEBRAIC', g.algebraicVariableTypeString()) - g.setAlgebraicVariableTypeString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.algebraicVariableTypeString()) - - def test_external_variable_type_string(self): - from libcellml import GeneratorProfile - - g = GeneratorProfile() - - self.assertEqual('EXTERNAL', g.externalVariableTypeString()) - g.setExternalVariableTypeString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableTypeString()) - def test_and_function_string(self): from libcellml import GeneratorProfile @@ -396,15 +378,6 @@ def test_common_logarithm_string(self): g.setCommonLogarithmString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.commonLogarithmString()) - def test_computed_constant_variable_type_string(self): - from libcellml import GeneratorProfile - - g = GeneratorProfile() - - self.assertEqual('COMPUTED_CONSTANT', g.computedConstantVariableTypeString()) - g.setComputedConstantVariableTypeString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.computedConstantVariableTypeString()) - def test_conditional_operator_else_string(self): from libcellml import GeneratorProfile @@ -423,33 +396,6 @@ def test_conditional_operator_if_string(self): g.setConditionalOperatorIfString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.conditionalOperatorIfString()) - def test_variable_of_integration_variable_type_string(self): - from libcellml import GeneratorProfile - - g = GeneratorProfile() - - self.assertEqual('VARIABLE_OF_INTEGRATION', g.variableOfIntegrationVariableTypeString()) - g.setVariableOfIntegrationVariableTypeString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.variableOfIntegrationVariableTypeString()) - - def test_state_variable_type_string(self): - from libcellml import GeneratorProfile - - g = GeneratorProfile() - - self.assertEqual('STATE', g.stateVariableTypeString()) - g.setStateVariableTypeString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.stateVariableTypeString()) - - def test_constant_variable_type_string(self): - from libcellml import GeneratorProfile - - g = GeneratorProfile() - - self.assertEqual('CONSTANT', g.constantVariableTypeString()) - g.setConstantVariableTypeString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.constantVariableTypeString()) - def test_cos_string(self): from libcellml import GeneratorProfile @@ -1634,7 +1580,7 @@ def test_variable_info_entry_string(self): g = GeneratorProfile() - self.assertEqual('{"[NAME]", "[UNITS]", "[COMPONENT]", [TYPE]}', g.variableInfoEntryString()) + self.assertEqual('{"[NAME]", "[UNITS]", "[COMPONENT]"}', g.variableInfoEntryString()) g.setVariableInfoEntryString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.variableInfoEntryString()) @@ -1644,40 +1590,11 @@ def test_variable_info_object_string(self): g = GeneratorProfile() self.assertEqual( - 'typedef struct {\n char name[[NAME_SIZE]];\n char units[[UNITS_SIZE]];\n char component[[COMPONENT_SIZE]];\n VariableType type;\n} VariableInfo;\n', + 'typedef struct {\n char name[[NAME_SIZE]];\n char units[[UNITS_SIZE]];\n char component[[COMPONENT_SIZE]];\n} VariableInfo;\n', g.variableInfoObjectString()) g.setVariableInfoObjectString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.variableInfoObjectString()) - def test_variable_type_object_string(self): - from libcellml import GeneratorProfile - - g = GeneratorProfile() - - self.assertEqual( - 'typedef enum {\n CONSTANT,\n COMPUTED_CONSTANT,\n ALGEBRAIC\n} VariableType;\n', - g.variableTypeObjectString(False, False)) - g.setVariableTypeObjectString(False, False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.variableTypeObjectString(False, False)) - - self.assertEqual( - 'typedef enum {\n CONSTANT,\n COMPUTED_CONSTANT,\n ALGEBRAIC,\n EXTERNAL\n} VariableType;\n', - g.variableTypeObjectString(False, True)) - g.setVariableTypeObjectString(False, True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.variableTypeObjectString(False, True)) - - self.assertEqual( - 'typedef enum {\n VARIABLE_OF_INTEGRATION,\n STATE,\n CONSTANT,\n COMPUTED_CONSTANT,\n ALGEBRAIC\n} VariableType;\n', - g.variableTypeObjectString(True, False)) - g.setVariableTypeObjectString(True, False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.variableTypeObjectString(True, False)) - - self.assertEqual( - 'typedef enum {\n VARIABLE_OF_INTEGRATION,\n STATE,\n CONSTANT,\n COMPUTED_CONSTANT,\n ALGEBRAIC,\n EXTERNAL\n} VariableType;\n', - g.variableTypeObjectString(True, True)) - g.setVariableTypeObjectString(True, True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.variableTypeObjectString(True, True)) - def test_constants_array_string(self): from libcellml import GeneratorProfile diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 2a6a53ea7..b2e37fbab 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -718,18 +718,6 @@ TEST(Coverage, generator) profile->setImplementationAlgebraicCountString(""); profile->setImplementationExternalCountString(""); - profile->setVariableTypeObjectString(false, false, ""); - profile->setVariableTypeObjectString(false, true, ""); - profile->setVariableTypeObjectString(true, false, ""); - profile->setVariableTypeObjectString(true, true, ""); - - profile->setVariableOfIntegrationVariableTypeString(""); - profile->setStateVariableTypeString(""); - profile->setConstantVariableTypeString(""); - profile->setComputedConstantVariableTypeString(""); - profile->setAlgebraicVariableTypeString(""); - profile->setExternalVariableTypeString(""); - profile->setVariableInfoObjectString(""); profile->setImplementationVoiInfoString(""); @@ -809,18 +797,6 @@ TEST(Coverage, generator) profile->setInterfaceExternalCountString(""); profile->setImplementationExternalCountString(""); - profile->setVariableTypeObjectString(false, false, ""); - profile->setVariableTypeObjectString(false, true, ""); - profile->setVariableTypeObjectString(true, false, ""); - profile->setVariableTypeObjectString(true, true, ""); - - profile->setVariableOfIntegrationVariableTypeString(""); - profile->setStateVariableTypeString(""); - profile->setConstantVariableTypeString(""); - profile->setComputedConstantVariableTypeString(""); - profile->setAlgebraicVariableTypeString(""); - profile->setExternalVariableTypeString(""); - profile->setVariableInfoObjectString(""); profile->setInterfaceVoiInfoString(""); @@ -926,32 +902,6 @@ TEST(Coverage, generator) profile->setFindRootCallString(true, ""); profile->setNlaSolveCallString(false, ""); profile->setNlaSolveCallString(true, ""); - profile->setVariableOfIntegrationVariableTypeString(""); - - generator->implementationCode(); - - profile->setStateVariableTypeString(""); - profile->setVariableOfIntegrationVariableTypeString("xxx"); - - generator->implementationCode(); - - profile->setConstantVariableTypeString(""); - profile->setStateVariableTypeString("xxx"); - - generator->implementationCode(); - - profile->setComputedConstantVariableTypeString(""); - profile->setConstantVariableTypeString("xxx"); - - generator->implementationCode(); - - profile->setComputedConstantVariableTypeString("xxx"); - profile->setAlgebraicVariableTypeString(""); - - generator->implementationCode(); - - profile->setAlgebraicVariableTypeString("xxx"); - profile->setExternalVariableTypeString(""); generator->implementationCode(); diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 7f079b5c0..97cba4127 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -291,49 +291,10 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("extern const size_t EXTERNAL_COUNT;\n", generatorProfile->interfaceExternalCountString()); EXPECT_EQ("const size_t EXTERNAL_COUNT = [EXTERNAL_COUNT];\n", generatorProfile->implementationExternalCountString()); - EXPECT_EQ("typedef enum {\n" - " CONSTANT,\n" - " COMPUTED_CONSTANT,\n" - " ALGEBRAIC\n" - "} VariableType;\n", - generatorProfile->variableTypeObjectString(false, false)); - EXPECT_EQ("typedef enum {\n" - " CONSTANT,\n" - " COMPUTED_CONSTANT,\n" - " ALGEBRAIC,\n" - " EXTERNAL\n" - "} VariableType;\n", - generatorProfile->variableTypeObjectString(false, true)); - EXPECT_EQ("typedef enum {\n" - " VARIABLE_OF_INTEGRATION,\n" - " STATE,\n" - " CONSTANT,\n" - " COMPUTED_CONSTANT,\n" - " ALGEBRAIC\n" - "} VariableType;\n", - generatorProfile->variableTypeObjectString(true, false)); - EXPECT_EQ("typedef enum {\n" - " VARIABLE_OF_INTEGRATION,\n" - " STATE,\n" - " CONSTANT,\n" - " COMPUTED_CONSTANT,\n" - " ALGEBRAIC,\n" - " EXTERNAL\n" - "} VariableType;\n", - generatorProfile->variableTypeObjectString(true, true)); - - EXPECT_EQ("VARIABLE_OF_INTEGRATION", generatorProfile->variableOfIntegrationVariableTypeString()); - EXPECT_EQ("STATE", generatorProfile->stateVariableTypeString()); - EXPECT_EQ("CONSTANT", generatorProfile->constantVariableTypeString()); - EXPECT_EQ("COMPUTED_CONSTANT", generatorProfile->computedConstantVariableTypeString()); - EXPECT_EQ("ALGEBRAIC", generatorProfile->algebraicVariableTypeString()); - EXPECT_EQ("EXTERNAL", generatorProfile->externalVariableTypeString()); - EXPECT_EQ("typedef struct {\n" " char name[[NAME_SIZE]];\n" " char units[[UNITS_SIZE]];\n" " char component[[COMPONENT_SIZE]];\n" - " VariableType type;\n" "} VariableInfo;\n", generatorProfile->variableInfoObjectString()); @@ -370,7 +331,7 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "};\n", generatorProfile->implementationExternalInfoString()); - EXPECT_EQ("{\"[NAME]\", \"[UNITS]\", \"[COMPONENT]\", [TYPE]}", generatorProfile->variableInfoEntryString()); + EXPECT_EQ("{\"[NAME]\", \"[UNITS]\", \"[COMPONENT]\"}", generatorProfile->variableInfoEntryString()); EXPECT_EQ("voi", generatorProfile->voiString()); @@ -906,18 +867,6 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setInterfaceExternalCountString(value); generatorProfile->setImplementationExternalCountString(value); - generatorProfile->setVariableTypeObjectString(false, false, value); - generatorProfile->setVariableTypeObjectString(false, true, value); - generatorProfile->setVariableTypeObjectString(true, false, value); - generatorProfile->setVariableTypeObjectString(true, true, value); - - generatorProfile->setVariableOfIntegrationVariableTypeString(value); - generatorProfile->setStateVariableTypeString(value); - generatorProfile->setConstantVariableTypeString(value); - generatorProfile->setComputedConstantVariableTypeString(value); - generatorProfile->setAlgebraicVariableTypeString(value); - generatorProfile->setExternalVariableTypeString(value); - generatorProfile->setVariableInfoObjectString(value); generatorProfile->setInterfaceVoiInfoString(value); @@ -1055,18 +1004,6 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->interfaceExternalCountString()); EXPECT_EQ(value, generatorProfile->implementationExternalCountString()); - EXPECT_EQ(value, generatorProfile->variableTypeObjectString(false, false)); - EXPECT_EQ(value, generatorProfile->variableTypeObjectString(false, true)); - EXPECT_EQ(value, generatorProfile->variableTypeObjectString(true, false)); - EXPECT_EQ(value, generatorProfile->variableTypeObjectString(true, true)); - - EXPECT_EQ(value, generatorProfile->variableOfIntegrationVariableTypeString()); - EXPECT_EQ(value, generatorProfile->stateVariableTypeString()); - EXPECT_EQ(value, generatorProfile->constantVariableTypeString()); - EXPECT_EQ(value, generatorProfile->computedConstantVariableTypeString()); - EXPECT_EQ(value, generatorProfile->algebraicVariableTypeString()); - EXPECT_EQ(value, generatorProfile->externalVariableTypeString()); - EXPECT_EQ(value, generatorProfile->variableInfoObjectString()); EXPECT_EQ(value, generatorProfile->interfaceVoiInfoString()); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index c354ffd2c..e65de4ae9 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -13,228 +13,228 @@ const size_t CONSTANT_COUNT = 7; const size_t COMPUTED_CONSTANT_COUNT = 200; const size_t ALGEBRAIC_COUNT = 2; -const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_component", STATE} + {"x", "dimensionless", "my_component"} }; const VariableInfo CONSTANT_INFO[] = { - {"m", "dimensionless", "my_component", CONSTANT}, - {"n", "dimensionless", "my_component", CONSTANT}, - {"o", "dimensionless", "my_component", CONSTANT}, - {"p", "dimensionless", "my_component", CONSTANT}, - {"q", "dimensionless", "my_component", CONSTANT}, - {"r", "dimensionless", "my_component", CONSTANT}, - {"s", "dimensionless", "my_component", CONSTANT} + {"m", "dimensionless", "my_component"}, + {"n", "dimensionless", "my_component"}, + {"o", "dimensionless", "my_component"}, + {"p", "dimensionless", "my_component"}, + {"q", "dimensionless", "my_component"}, + {"r", "dimensionless", "my_component"}, + {"s", "dimensionless", "my_component"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"eqnEq", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnEqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnNeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnNeqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLt", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLtCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLeqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnGt", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnGtCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnGeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnGeqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAnd", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOr", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXor", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnNot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPlus", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPlusMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPlusParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPlusUnary", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinus", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusParenthesesPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusParenthesesPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusParenthesesDirectUnaryMinus", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusParenthesesIndirectUnaryMinus", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusUnary", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusUnaryParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerSqrt", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerSqr", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerCube", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerCi", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootSqrt", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootSqrtOther", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootCube", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootCi", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAbs", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnExp", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLn", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLog", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLog2", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLog10", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLogCi", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCeiling", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnFloor", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMin", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMax", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMaxMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRem", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnSin", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCos", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTan", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnSec", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCsc", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnSinh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCosh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTanh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnSech", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCsch", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoth", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArcsin", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccos", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArctan", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArcsec", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccsc", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArcsinh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccosh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArctanh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArcsech", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccsch", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccoth", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPiecewisePiece", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPiecewisePieceOtherwise", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPiecewisePiecePiecePiece", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPiecewisePiecePiecePieceOtherwise", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnWithPiecewise", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCnInteger", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCnDouble", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCnIntegerWithExponent", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCnDoubleWithExponent", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCi", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTrue", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnFalse", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnExponentiale", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPi", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnInfinity", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnNotanumber", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForPlusOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForMinusOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForTimesOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForDivideOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForAndOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForOrOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForXorOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForPowerOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForRootOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForMinusUnary", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnComputedConstant1", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnComputedConstant2", "dimensionless", "my_component", COMPUTED_CONSTANT} + {"eqnEq", "dimensionless", "my_component"}, + {"eqnEqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNeq", "dimensionless", "my_component"}, + {"eqnNeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLt", "dimensionless", "my_component"}, + {"eqnLtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLeq", "dimensionless", "my_component"}, + {"eqnLeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGt", "dimensionless", "my_component"}, + {"eqnGtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGeq", "dimensionless", "my_component"}, + {"eqnGeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnAnd", "dimensionless", "my_component"}, + {"eqnAndMultiple", "dimensionless", "my_component"}, + {"eqnAndParentheses", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAndCoverageParentheses", "dimensionless", "my_component"}, + {"eqnOr", "dimensionless", "my_component"}, + {"eqnOrMultiple", "dimensionless", "my_component"}, + {"eqnOrParentheses", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnOrCoverageParentheses", "dimensionless", "my_component"}, + {"eqnXor", "dimensionless", "my_component"}, + {"eqnXorMultiple", "dimensionless", "my_component"}, + {"eqnXorParentheses", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnXorCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNot", "dimensionless", "my_component"}, + {"eqnPlus", "dimensionless", "my_component"}, + {"eqnPlusMultiple", "dimensionless", "my_component"}, + {"eqnPlusParentheses", "dimensionless", "my_component"}, + {"eqnPlusUnary", "dimensionless", "my_component"}, + {"eqnMinus", "dimensionless", "my_component"}, + {"eqnMinusParentheses", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWith", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWithout", "dimensionless", "my_component"}, + {"eqnMinusParenthesesDirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusParenthesesIndirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusUnary", "dimensionless", "my_component"}, + {"eqnMinusUnaryParentheses", "dimensionless", "my_component"}, + {"eqnTimes", "dimensionless", "my_component"}, + {"eqnTimesMultiple", "dimensionless", "my_component"}, + {"eqnTimesParentheses", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivide", "dimensionless", "my_component"}, + {"eqnDivideParentheses", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerSqrt", "dimensionless", "my_component"}, + {"eqnPowerSqr", "dimensionless", "my_component"}, + {"eqnPowerCube", "dimensionless", "my_component"}, + {"eqnPowerCi", "dimensionless", "my_component"}, + {"eqnPowerParentheses", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnRootSqrt", "dimensionless", "my_component"}, + {"eqnRootSqrtOther", "dimensionless", "my_component"}, + {"eqnRootCube", "dimensionless", "my_component"}, + {"eqnRootCi", "dimensionless", "my_component"}, + {"eqnRootParentheses", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAbs", "dimensionless", "my_component"}, + {"eqnExp", "dimensionless", "my_component"}, + {"eqnLn", "dimensionless", "my_component"}, + {"eqnLog", "dimensionless", "my_component"}, + {"eqnLog2", "dimensionless", "my_component"}, + {"eqnLog10", "dimensionless", "my_component"}, + {"eqnLogCi", "dimensionless", "my_component"}, + {"eqnCeiling", "dimensionless", "my_component"}, + {"eqnFloor", "dimensionless", "my_component"}, + {"eqnMin", "dimensionless", "my_component"}, + {"eqnMinMultiple", "dimensionless", "my_component"}, + {"eqnMax", "dimensionless", "my_component"}, + {"eqnMaxMultiple", "dimensionless", "my_component"}, + {"eqnRem", "dimensionless", "my_component"}, + {"eqnSin", "dimensionless", "my_component"}, + {"eqnCos", "dimensionless", "my_component"}, + {"eqnTan", "dimensionless", "my_component"}, + {"eqnSec", "dimensionless", "my_component"}, + {"eqnCsc", "dimensionless", "my_component"}, + {"eqnCot", "dimensionless", "my_component"}, + {"eqnSinh", "dimensionless", "my_component"}, + {"eqnCosh", "dimensionless", "my_component"}, + {"eqnTanh", "dimensionless", "my_component"}, + {"eqnSech", "dimensionless", "my_component"}, + {"eqnCsch", "dimensionless", "my_component"}, + {"eqnCoth", "dimensionless", "my_component"}, + {"eqnArcsin", "dimensionless", "my_component"}, + {"eqnArccos", "dimensionless", "my_component"}, + {"eqnArctan", "dimensionless", "my_component"}, + {"eqnArcsec", "dimensionless", "my_component"}, + {"eqnArccsc", "dimensionless", "my_component"}, + {"eqnArccot", "dimensionless", "my_component"}, + {"eqnArcsinh", "dimensionless", "my_component"}, + {"eqnArccosh", "dimensionless", "my_component"}, + {"eqnArctanh", "dimensionless", "my_component"}, + {"eqnArcsech", "dimensionless", "my_component"}, + {"eqnArccsch", "dimensionless", "my_component"}, + {"eqnArccoth", "dimensionless", "my_component"}, + {"eqnPiecewisePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePieceOtherwise", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePieceOtherwise", "dimensionless", "my_component"}, + {"eqnWithPiecewise", "dimensionless", "my_component"}, + {"eqnCnInteger", "dimensionless", "my_component"}, + {"eqnCnDouble", "dimensionless", "my_component"}, + {"eqnCnIntegerWithExponent", "dimensionless", "my_component"}, + {"eqnCnDoubleWithExponent", "dimensionless", "my_component"}, + {"eqnCi", "dimensionless", "my_component"}, + {"eqnTrue", "dimensionless", "my_component"}, + {"eqnFalse", "dimensionless", "my_component"}, + {"eqnExponentiale", "dimensionless", "my_component"}, + {"eqnPi", "dimensionless", "my_component"}, + {"eqnInfinity", "dimensionless", "my_component"}, + {"eqnNotanumber", "dimensionless", "my_component"}, + {"eqnCoverageForPlusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForTimesOperator", "dimensionless", "my_component"}, + {"eqnCoverageForDivideOperator", "dimensionless", "my_component"}, + {"eqnCoverageForAndOperator", "dimensionless", "my_component"}, + {"eqnCoverageForOrOperator", "dimensionless", "my_component"}, + {"eqnCoverageForXorOperator", "dimensionless", "my_component"}, + {"eqnCoverageForPowerOperator", "dimensionless", "my_component"}, + {"eqnCoverageForRootOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusUnary", "dimensionless", "my_component"}, + {"eqnComputedConstant1", "dimensionless", "my_component"}, + {"eqnComputedConstant2", "dimensionless", "my_component"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"eqnNlaVariable1", "dimensionless", "my_component", ALGEBRAIC}, - {"eqnNlaVariable2", "dimensionless", "my_component", ALGEBRAIC} + {"eqnNlaVariable1", "dimensionless", "my_component"}, + {"eqnNlaVariable2", "dimensionless", "my_component"} }; double xor(double x, double y) diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 07d230338..f394f9503 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[38]; char units[14]; char component[13]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index b81232df9..d63bb27d2 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -13,228 +13,228 @@ const size_t CONSTANT_COUNT = 7; const size_t COMPUTED_CONSTANT_COUNT = 200; const size_t ALGEBRAIC_COUNT = 2; -const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_component", STATE} + {"x", "dimensionless", "my_component"} }; const VariableInfo CONSTANT_INFO[] = { - {"m", "dimensionless", "my_component", CONSTANT}, - {"n", "dimensionless", "my_component", CONSTANT}, - {"o", "dimensionless", "my_component", CONSTANT}, - {"p", "dimensionless", "my_component", CONSTANT}, - {"q", "dimensionless", "my_component", CONSTANT}, - {"r", "dimensionless", "my_component", CONSTANT}, - {"s", "dimensionless", "my_component", CONSTANT} + {"m", "dimensionless", "my_component"}, + {"n", "dimensionless", "my_component"}, + {"o", "dimensionless", "my_component"}, + {"p", "dimensionless", "my_component"}, + {"q", "dimensionless", "my_component"}, + {"r", "dimensionless", "my_component"}, + {"s", "dimensionless", "my_component"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"eqnEq", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnEqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnNeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnNeqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLt", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLtCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLeqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnGt", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnGtCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnGeq", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnGeqCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAnd", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesLeftRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndParenthesesRightRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAndCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOr", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesLeftRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrParenthesesRightRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnOrCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXor", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesLeftRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorParenthesesRightRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnXorCoverageParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnNot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPlus", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPlusMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPlusParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPlusUnary", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinus", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusParenthesesPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusParenthesesPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusParenthesesDirectUnaryMinus", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusParenthesesIndirectUnaryMinus", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusUnary", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinusUnaryParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTimesParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnDivideParenthesesRightDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerSqrt", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerSqr", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerCube", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerCi", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesLeftDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPowerParenthesesRightRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootSqrt", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootSqrtOther", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootCube", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootCi", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParentheses", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesLeftDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightPlusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightPlusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightMinusWith", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightMinusWithout", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightTimes", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightDivide", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightPower", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRootParenthesesRightRoot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnAbs", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnExp", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLn", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLog", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLog2", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLog10", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnLogCi", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCeiling", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnFloor", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMin", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMinMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMax", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnMaxMultiple", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnRem", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnSin", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCos", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTan", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnSec", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCsc", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnSinh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCosh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTanh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnSech", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCsch", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoth", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArcsin", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccos", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArctan", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArcsec", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccsc", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccot", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArcsinh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccosh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArctanh", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArcsech", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccsch", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnArccoth", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPiecewisePiece", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPiecewisePieceOtherwise", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPiecewisePiecePiecePiece", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPiecewisePiecePiecePieceOtherwise", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnWithPiecewise", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCnInteger", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCnDouble", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCnIntegerWithExponent", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCnDoubleWithExponent", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCi", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnTrue", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnFalse", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnExponentiale", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnPi", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnInfinity", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnNotanumber", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForPlusOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForMinusOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForTimesOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForDivideOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForAndOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForOrOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForXorOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForPowerOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForRootOperator", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnCoverageForMinusUnary", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnComputedConstant1", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"eqnComputedConstant2", "dimensionless", "my_component", COMPUTED_CONSTANT} + {"eqnEq", "dimensionless", "my_component"}, + {"eqnEqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNeq", "dimensionless", "my_component"}, + {"eqnNeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLt", "dimensionless", "my_component"}, + {"eqnLtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnLeq", "dimensionless", "my_component"}, + {"eqnLeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGt", "dimensionless", "my_component"}, + {"eqnGtCoverageParentheses", "dimensionless", "my_component"}, + {"eqnGeq", "dimensionless", "my_component"}, + {"eqnGeqCoverageParentheses", "dimensionless", "my_component"}, + {"eqnAnd", "dimensionless", "my_component"}, + {"eqnAndMultiple", "dimensionless", "my_component"}, + {"eqnAndParentheses", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnAndParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAndCoverageParentheses", "dimensionless", "my_component"}, + {"eqnOr", "dimensionless", "my_component"}, + {"eqnOrMultiple", "dimensionless", "my_component"}, + {"eqnOrParentheses", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnOrParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnOrCoverageParentheses", "dimensionless", "my_component"}, + {"eqnXor", "dimensionless", "my_component"}, + {"eqnXorMultiple", "dimensionless", "my_component"}, + {"eqnXorParentheses", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesLeftRoot", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnXorParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnXorCoverageParentheses", "dimensionless", "my_component"}, + {"eqnNot", "dimensionless", "my_component"}, + {"eqnPlus", "dimensionless", "my_component"}, + {"eqnPlusMultiple", "dimensionless", "my_component"}, + {"eqnPlusParentheses", "dimensionless", "my_component"}, + {"eqnPlusUnary", "dimensionless", "my_component"}, + {"eqnMinus", "dimensionless", "my_component"}, + {"eqnMinusParentheses", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWith", "dimensionless", "my_component"}, + {"eqnMinusParenthesesPlusWithout", "dimensionless", "my_component"}, + {"eqnMinusParenthesesDirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusParenthesesIndirectUnaryMinus", "dimensionless", "my_component"}, + {"eqnMinusUnary", "dimensionless", "my_component"}, + {"eqnMinusUnaryParentheses", "dimensionless", "my_component"}, + {"eqnTimes", "dimensionless", "my_component"}, + {"eqnTimesMultiple", "dimensionless", "my_component"}, + {"eqnTimesParentheses", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnTimesParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivide", "dimensionless", "my_component"}, + {"eqnDivideParentheses", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnDivideParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerSqrt", "dimensionless", "my_component"}, + {"eqnPowerSqr", "dimensionless", "my_component"}, + {"eqnPowerCube", "dimensionless", "my_component"}, + {"eqnPowerCi", "dimensionless", "my_component"}, + {"eqnPowerParentheses", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnPowerParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnRootSqrt", "dimensionless", "my_component"}, + {"eqnRootSqrtOther", "dimensionless", "my_component"}, + {"eqnRootCube", "dimensionless", "my_component"}, + {"eqnRootCi", "dimensionless", "my_component"}, + {"eqnRootParentheses", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesLeftDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPlusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWith", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightMinusWithout", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightTimes", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightDivide", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightPower", "dimensionless", "my_component"}, + {"eqnRootParenthesesRightRoot", "dimensionless", "my_component"}, + {"eqnAbs", "dimensionless", "my_component"}, + {"eqnExp", "dimensionless", "my_component"}, + {"eqnLn", "dimensionless", "my_component"}, + {"eqnLog", "dimensionless", "my_component"}, + {"eqnLog2", "dimensionless", "my_component"}, + {"eqnLog10", "dimensionless", "my_component"}, + {"eqnLogCi", "dimensionless", "my_component"}, + {"eqnCeiling", "dimensionless", "my_component"}, + {"eqnFloor", "dimensionless", "my_component"}, + {"eqnMin", "dimensionless", "my_component"}, + {"eqnMinMultiple", "dimensionless", "my_component"}, + {"eqnMax", "dimensionless", "my_component"}, + {"eqnMaxMultiple", "dimensionless", "my_component"}, + {"eqnRem", "dimensionless", "my_component"}, + {"eqnSin", "dimensionless", "my_component"}, + {"eqnCos", "dimensionless", "my_component"}, + {"eqnTan", "dimensionless", "my_component"}, + {"eqnSec", "dimensionless", "my_component"}, + {"eqnCsc", "dimensionless", "my_component"}, + {"eqnCot", "dimensionless", "my_component"}, + {"eqnSinh", "dimensionless", "my_component"}, + {"eqnCosh", "dimensionless", "my_component"}, + {"eqnTanh", "dimensionless", "my_component"}, + {"eqnSech", "dimensionless", "my_component"}, + {"eqnCsch", "dimensionless", "my_component"}, + {"eqnCoth", "dimensionless", "my_component"}, + {"eqnArcsin", "dimensionless", "my_component"}, + {"eqnArccos", "dimensionless", "my_component"}, + {"eqnArctan", "dimensionless", "my_component"}, + {"eqnArcsec", "dimensionless", "my_component"}, + {"eqnArccsc", "dimensionless", "my_component"}, + {"eqnArccot", "dimensionless", "my_component"}, + {"eqnArcsinh", "dimensionless", "my_component"}, + {"eqnArccosh", "dimensionless", "my_component"}, + {"eqnArctanh", "dimensionless", "my_component"}, + {"eqnArcsech", "dimensionless", "my_component"}, + {"eqnArccsch", "dimensionless", "my_component"}, + {"eqnArccoth", "dimensionless", "my_component"}, + {"eqnPiecewisePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePieceOtherwise", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePiece", "dimensionless", "my_component"}, + {"eqnPiecewisePiecePiecePieceOtherwise", "dimensionless", "my_component"}, + {"eqnWithPiecewise", "dimensionless", "my_component"}, + {"eqnCnInteger", "dimensionless", "my_component"}, + {"eqnCnDouble", "dimensionless", "my_component"}, + {"eqnCnIntegerWithExponent", "dimensionless", "my_component"}, + {"eqnCnDoubleWithExponent", "dimensionless", "my_component"}, + {"eqnCi", "dimensionless", "my_component"}, + {"eqnTrue", "dimensionless", "my_component"}, + {"eqnFalse", "dimensionless", "my_component"}, + {"eqnExponentiale", "dimensionless", "my_component"}, + {"eqnPi", "dimensionless", "my_component"}, + {"eqnInfinity", "dimensionless", "my_component"}, + {"eqnNotanumber", "dimensionless", "my_component"}, + {"eqnCoverageForPlusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusOperator", "dimensionless", "my_component"}, + {"eqnCoverageForTimesOperator", "dimensionless", "my_component"}, + {"eqnCoverageForDivideOperator", "dimensionless", "my_component"}, + {"eqnCoverageForAndOperator", "dimensionless", "my_component"}, + {"eqnCoverageForOrOperator", "dimensionless", "my_component"}, + {"eqnCoverageForXorOperator", "dimensionless", "my_component"}, + {"eqnCoverageForPowerOperator", "dimensionless", "my_component"}, + {"eqnCoverageForRootOperator", "dimensionless", "my_component"}, + {"eqnCoverageForMinusUnary", "dimensionless", "my_component"}, + {"eqnComputedConstant1", "dimensionless", "my_component"}, + {"eqnComputedConstant2", "dimensionless", "my_component"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"eqnNlaVariable1", "dimensionless", "my_component", ALGEBRAIC}, - {"eqnNlaVariable2", "dimensionless", "my_component", ALGEBRAIC} + {"eqnNlaVariable1", "dimensionless", "my_component"}, + {"eqnNlaVariable2", "dimensionless", "my_component"} }; double xor(double x, double y) diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 7bb7462be..fb41e8e19 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[38]; char units[14]; char component[13]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index c7b36b99d..450b76136 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -12,236 +12,227 @@ COMPUTED_CONSTANT_COUNT = 200 ALGEBRAIC_COUNT = 2 +VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} CONSTANT_INFO = [ - {"name": "m", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "n", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "o", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "p", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "q", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "r", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "s", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT} + {"name": "m", "units": "dimensionless", "component": "my_component"}, + {"name": "n", "units": "dimensionless", "component": "my_component"}, + {"name": "o", "units": "dimensionless", "component": "my_component"}, + {"name": "p", "units": "dimensionless", "component": "my_component"}, + {"name": "q", "units": "dimensionless", "component": "my_component"}, + {"name": "r", "units": "dimensionless", "component": "my_component"}, + {"name": "s", "units": "dimensionless", "component": "my_component"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "eqnEq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnNeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnNeqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLt", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLtCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLeqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnGt", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnGtCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnGeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnGeqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAnd", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOr", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXor", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnNot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPlus", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPlusMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPlusParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPlusUnary", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinus", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusParenthesesPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusParenthesesPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusParenthesesDirectUnaryMinus", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusParenthesesIndirectUnaryMinus", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusUnary", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusUnaryParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerSqrt", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerSqr", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerCube", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerCi", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootSqrt", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootSqrtOther", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootCube", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootCi", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAbs", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnExp", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLn", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLog", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLog2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLog10", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLogCi", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCeiling", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnFloor", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMin", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMax", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMaxMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRem", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnSin", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCos", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTan", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnSec", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCsc", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnSinh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCosh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTanh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnSech", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCsch", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoth", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArcsin", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccos", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArctan", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArcsec", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccsc", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArcsinh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccosh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArctanh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArcsech", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccsch", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccoth", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPiecewisePiece", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPiecewisePieceOtherwise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPiecewisePiecePiecePiece", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPiecewisePiecePiecePieceOtherwise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnWithPiecewise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCnInteger", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCnDouble", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCnIntegerWithExponent", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCnDoubleWithExponent", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCi", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTrue", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnFalse", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnExponentiale", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPi", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnInfinity", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnNotanumber", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForPlusOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForMinusOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForTimesOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForDivideOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForAndOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForOrOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForXorOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} + {"name": "eqnEq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAnd", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesDirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesIndirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnaryParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrtOther", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAbs", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExp", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLn", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog10", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLogCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCeiling", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFloor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMax", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMaxMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRem", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnWithPiecewise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnInteger", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDouble", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnIntegerWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDoubleWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTrue", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFalse", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExponentiale", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnInfinity", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNotanumber", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPlusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForTimesOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForDivideOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForAndOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForOrOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForXorOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"} ] ALGEBRAIC_INFO = [ - {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC}, - {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC} + {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"} ] diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index bea011a82..0ddd0fe1e 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -12,236 +12,227 @@ COMPUTED_CONSTANT_COUNT = 200 ALGEBRAIC_COUNT = 2 +VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} CONSTANT_INFO = [ - {"name": "m", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "n", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "o", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "p", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "q", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "r", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT}, - {"name": "s", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT} + {"name": "m", "units": "dimensionless", "component": "my_component"}, + {"name": "n", "units": "dimensionless", "component": "my_component"}, + {"name": "o", "units": "dimensionless", "component": "my_component"}, + {"name": "p", "units": "dimensionless", "component": "my_component"}, + {"name": "q", "units": "dimensionless", "component": "my_component"}, + {"name": "r", "units": "dimensionless", "component": "my_component"}, + {"name": "s", "units": "dimensionless", "component": "my_component"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "eqnEq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnNeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnNeqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLt", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLtCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLeqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnGt", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnGtCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnGeq", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnGeqCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAnd", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesLeftRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndParenthesesRightRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAndCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOr", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesLeftRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrParenthesesRightRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnOrCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXor", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesLeftRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorParenthesesRightRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnXorCoverageParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnNot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPlus", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPlusMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPlusParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPlusUnary", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinus", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusParenthesesPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusParenthesesPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusParenthesesDirectUnaryMinus", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusParenthesesIndirectUnaryMinus", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusUnary", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinusUnaryParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTimesParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnDivideParenthesesRightDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerSqrt", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerSqr", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerCube", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerCi", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesLeftDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPowerParenthesesRightRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootSqrt", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootSqrtOther", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootCube", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootCi", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParentheses", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesLeftDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightTimes", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightDivide", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightPower", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRootParenthesesRightRoot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnAbs", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnExp", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLn", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLog", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLog2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLog10", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnLogCi", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCeiling", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnFloor", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMin", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMinMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMax", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnMaxMultiple", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnRem", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnSin", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCos", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTan", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnSec", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCsc", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnSinh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCosh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTanh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnSech", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCsch", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoth", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArcsin", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccos", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArctan", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArcsec", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccsc", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccot", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArcsinh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccosh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArctanh", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArcsech", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccsch", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnArccoth", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPiecewisePiece", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPiecewisePieceOtherwise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPiecewisePiecePiecePiece", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPiecewisePiecePiecePieceOtherwise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnWithPiecewise", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCnInteger", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCnDouble", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCnIntegerWithExponent", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCnDoubleWithExponent", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCi", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnTrue", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnFalse", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnExponentiale", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnPi", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnInfinity", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnNotanumber", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForPlusOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForMinusOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForTimesOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForDivideOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForAndOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForOrOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForXorOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} + {"name": "eqnEq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnEqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGtCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeq", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnGeqCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAnd", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAndCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnOrCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesLeftRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnXorCoverageParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPlusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesDirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusParenthesesIndirectUnaryMinus", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinusUnaryParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTimesParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnDivideParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerSqr", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPowerParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrt", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootSqrtOther", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCube", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParentheses", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesLeftDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPlusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWith", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightMinusWithout", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightTimes", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightDivide", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightPower", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRootParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnAbs", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExp", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLn", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLog10", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnLogCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCeiling", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFloor", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMinMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMax", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnMaxMultiple", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnRem", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnSech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsin", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccos", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctan", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsec", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsc", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccot", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsinh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccosh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArctanh", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArcsech", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccsch", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnArccoth", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePiece", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPiecewisePiecePiecePieceOtherwise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnWithPiecewise", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnInteger", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDouble", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnIntegerWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCnDoubleWithExponent", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnTrue", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnFalse", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnExponentiale", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnPi", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnInfinity", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNotanumber", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPlusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForTimesOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForDivideOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForAndOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForOrOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForXorOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"} ] ALGEBRAIC_INFO = [ - {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC}, - {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component", "type": VariableType.ALGEBRAIC} + {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"} ] diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index 93b538b35..d3373bd80 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -16,8 +16,8 @@ const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"x", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, - {"a", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT} + {"x", "dimensionless", "my_algebraic_eqn"}, + {"a", "dimensionless", "my_algebraic_eqn"} }; const VariableInfo ALGEBRAIC_INFO[] = { diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 4d448046d..fcac8daa3 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -20,11 +20,11 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"x", "dimensionless", "my_algebraic_eqn", ALGEBRAIC} + {"x", "dimensionless", "my_algebraic_eqn"} }; const VariableInfo EXTERNAL_INFO[] = { - {"a", "dimensionless", "my_algebraic_eqn", EXTERNAL} + {"a", "dimensionless", "my_algebraic_eqn"} }; double * createVariablesArray() diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index da181acb2..ae517dbae 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -12,18 +12,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[2]; char units[14]; char component[17]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 267f46df4..5aad8e932 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -12,14 +12,6 @@ ALGEBRAIC_COUNT = 1 EXTERNAL_COUNT = 1 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - EXTERNAL = 3 - - CONSTANT_INFO = [ ] @@ -27,11 +19,11 @@ class VariableType(Enum): ] ALGEBRAIC_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.ALGEBRAIC} + {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn"} ] EXTERNAL_INFO = [ - {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.EXTERNAL} + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} ] diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index a14bcb399..e7483121b 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -11,17 +11,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[17]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index f4989919e..5b2757c65 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -11,19 +11,12 @@ COMPUTED_CONSTANT_COUNT = 2 ALGEBRAIC_COUNT = 0 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - - CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT} + {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} ] ALGEBRAIC_INFO = [ diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index 55fb1236a..f1a027bb9 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -13,11 +13,11 @@ const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { - {"a", "dimensionless", "my_algebraic_eqn", CONSTANT} + {"a", "dimensionless", "my_algebraic_eqn"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"x", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT} + {"x", "dimensionless", "my_algebraic_eqn"} }; const VariableInfo ALGEBRAIC_INFO[] = { diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index a14bcb399..e7483121b 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -11,17 +11,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[17]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index a6562fdf5..11f3c989c 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -11,19 +11,12 @@ COMPUTED_CONSTANT_COUNT = 1 ALGEBRAIC_COUNT = 0 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - - CONSTANT_INFO = [ - {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.CONSTANT} + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT} + {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn"} ] ALGEBRAIC_INFO = [ diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index 0c647741f..d675f0bf5 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -16,7 +16,7 @@ const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"x", "dimensionless", "my_component", COMPUTED_CONSTANT} + {"x", "dimensionless", "my_component"} }; const VariableInfo ALGEBRAIC_INFO[] = { diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index 2e7b0dd0b..c22b33894 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -11,17 +11,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[13]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index 8c32d995f..32441f8f5 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -11,18 +11,11 @@ COMPUTED_CONSTANT_COUNT = 1 ALGEBRAIC_COUNT = 0 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - - CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} + {"name": "x", "units": "dimensionless", "component": "my_component"} ] ALGEBRAIC_INFO = [ diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index ec215a064..b74b04c00 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -13,21 +13,21 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 1; -const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"v", "dimensionless", "my_ode", STATE} + {"v", "dimensionless", "my_ode"} }; const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"a", "per_s", "my_ode", COMPUTED_CONSTANT} + {"a", "per_s", "my_ode"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"x", "per_s", "my_algebraic_eqn", ALGEBRAIC} + {"x", "per_s", "my_algebraic_eqn"} }; double * createStatesArray() diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index bb606064c..897ad01fb 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[17]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 9a708f235..50a4280dd 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -12,29 +12,20 @@ COMPUTED_CONSTANT_COUNT = 1 ALGEBRAIC_COUNT = 1 +VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "v", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "v", "units": "dimensionless", "component": "my_ode"} CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ - {"name": "a", "units": "per_s", "component": "my_ode", "type": VariableType.COMPUTED_CONSTANT} + {"name": "a", "units": "per_s", "component": "my_ode"} ] ALGEBRAIC_INFO = [ - {"name": "x", "units": "per_s", "component": "my_algebraic_eqn", "type": VariableType.ALGEBRAIC} + {"name": "x", "units": "per_s", "component": "my_algebraic_eqn"} ] diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 1ca280481..b5dfae272 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -13,21 +13,21 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 1; -const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; const VariableInfo STATE_INFO[] = { - {"v", "dimensionless", "my_component", STATE} + {"v", "dimensionless", "my_component"} }; const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"a", "per_s", "my_component", COMPUTED_CONSTANT} + {"a", "per_s", "my_component"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"x", "per_s", "my_component", ALGEBRAIC} + {"x", "per_s", "my_component"} }; double * createStatesArray() diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index ec1099767..1c36d8d5f 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[13]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index b0f2b7a22..03b8c76bc 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -12,29 +12,20 @@ COMPUTED_CONSTANT_COUNT = 1 ALGEBRAIC_COUNT = 1 +VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "v", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "v", "units": "dimensionless", "component": "my_component"} CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ - {"name": "a", "units": "per_s", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} + {"name": "a", "units": "per_s", "component": "my_component"} ] ALGEBRAIC_INFO = [ - {"name": "x", "units": "per_s", "component": "my_component", "type": VariableType.ALGEBRAIC} + {"name": "x", "units": "per_s", "component": "my_component"} ] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 3a887564d..5d8fd74b9 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -13,21 +13,21 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 1; -const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_ode", STATE} + {"x", "dimensionless", "my_ode"} }; const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"a", "per_s", "my_ode", COMPUTED_CONSTANT} + {"a", "per_s", "my_ode"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"xx", "dimensionless", "my_algebraic_eqn", ALGEBRAIC} + {"xx", "dimensionless", "my_algebraic_eqn"} }; double * createStatesArray() diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index ca2d89ac4..5d58dcfbb 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[3]; char units[14]; char component[17]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 30fb1833d..20c3b7247 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -12,29 +12,20 @@ COMPUTED_CONSTANT_COUNT = 1 ALGEBRAIC_COUNT = 1 +VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode"} CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ - {"name": "a", "units": "per_s", "component": "my_ode", "type": VariableType.COMPUTED_CONSTANT} + {"name": "a", "units": "per_s", "component": "my_ode"} ] ALGEBRAIC_INFO = [ - {"name": "xx", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.ALGEBRAIC} + {"name": "xx", "units": "dimensionless", "component": "my_algebraic_eqn"} ] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index c25242a83..9312cbe36 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -13,21 +13,21 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 1; -const VariableInfo VOI_INFO = {"t", "second", "my_model", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "my_model"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_model", STATE} + {"x", "dimensionless", "my_model"} }; const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"a", "per_s", "my_model", COMPUTED_CONSTANT} + {"a", "per_s", "my_model"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"xx", "dimensionless", "my_model", ALGEBRAIC} + {"xx", "dimensionless", "my_model"} }; double * createStatesArray() diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index 204f85667..de15f76cf 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[3]; char units[14]; char component[9]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 81450104a..b20a4ecff 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -12,29 +12,20 @@ COMPUTED_CONSTANT_COUNT = 1 ALGEBRAIC_COUNT = 1 +VOI_INFO = {"name": "t", "units": "second", "component": "my_model"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "my_model", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_model", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_model"} CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ - {"name": "a", "units": "per_s", "component": "my_model", "type": VariableType.COMPUTED_CONSTANT} + {"name": "a", "units": "per_s", "component": "my_model"} ] ALGEBRAIC_INFO = [ - {"name": "xx", "units": "dimensionless", "component": "my_model", "type": VariableType.ALGEBRAIC} + {"name": "xx", "units": "dimensionless", "component": "my_model"} ] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 9729fbf02..c03fdb714 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -16,13 +16,13 @@ const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"b", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, - {"c", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, - {"d", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT} + {"b", "dimensionless", "my_algebraic_eqn"}, + {"c", "dimensionless", "my_algebraic_eqn"}, + {"d", "dimensionless", "my_algebraic_eqn"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"a", "dimensionless", "my_algebraic_eqn", ALGEBRAIC} + {"a", "dimensionless", "my_algebraic_eqn"} }; double * createVariablesArray() diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index 0dc47b9c0..dfeff7ef9 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -17,16 +17,16 @@ const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"b", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, - {"c", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT}, - {"d", "dimensionless", "my_algebraic_eqn", COMPUTED_CONSTANT} + {"b", "dimensionless", "my_algebraic_eqn"}, + {"c", "dimensionless", "my_algebraic_eqn"}, + {"d", "dimensionless", "my_algebraic_eqn"} }; const VariableInfo ALGEBRAIC_INFO[] = { }; const VariableInfo EXTERNAL_INFO[] = { - {"a", "dimensionless", "my_algebraic_eqn", EXTERNAL} + {"a", "dimensionless", "my_algebraic_eqn"} }; double * createVariablesArray() diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index da181acb2..ae517dbae 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -12,18 +12,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[2]; char units[14]; char component[17]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index abab654ef..c63f98fa9 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -12,28 +12,20 @@ ALGEBRAIC_COUNT = 0 EXTERNAL_COUNT = 1 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - EXTERNAL = 3 - - CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ - {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT} + {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn"} ] ALGEBRAIC_INFO = [ ] EXTERNAL_INFO = [ - {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.EXTERNAL} + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} ] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index a14bcb399..e7483121b 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -11,17 +11,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[17]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 47a6536ef..ac5049aa0 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -11,24 +11,17 @@ COMPUTED_CONSTANT_COUNT = 3 ALGEBRAIC_COUNT = 1 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - - CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ - {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.COMPUTED_CONSTANT} + {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn"} ] ALGEBRAIC_INFO = [ - {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn", "type": VariableType.ALGEBRAIC} + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} ] diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index 10613b828..650710a25 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -19,9 +19,9 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"x", "dimensionless", "my_algebraic_system", ALGEBRAIC}, - {"y", "dimensionless", "my_algebraic_system", ALGEBRAIC}, - {"z", "dimensionless", "my_algebraic_system", ALGEBRAIC} + {"x", "dimensionless", "my_algebraic_system"}, + {"y", "dimensionless", "my_algebraic_system"}, + {"z", "dimensionless", "my_algebraic_system"} }; double * createVariablesArray() diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index 6633bbe21..a8b4dbbcc 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -11,17 +11,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[20]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 797157fd5..00c16f398 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -11,13 +11,6 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 3 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - - CONSTANT_INFO = [ ] @@ -25,9 +18,9 @@ class VariableType(Enum): ] ALGEBRAIC_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, - {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, - {"name": "z", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC} + {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "z", "units": "dimensionless", "component": "my_algebraic_system"} ] diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index 5596bf8a6..d2d15bfa5 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -23,9 +23,9 @@ const VariableInfo ALGEBRAIC_INFO[] = { }; const VariableInfo EXTERNAL_INFO[] = { - {"x", "dimensionless", "my_algebraic_system", EXTERNAL}, - {"y", "dimensionless", "my_algebraic_system", EXTERNAL}, - {"z", "dimensionless", "my_algebraic_system", EXTERNAL} + {"x", "dimensionless", "my_algebraic_system"}, + {"y", "dimensionless", "my_algebraic_system"}, + {"z", "dimensionless", "my_algebraic_system"} }; double * createVariablesArray() diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index a2a7d679f..7e21388ca 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -12,18 +12,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[2]; char units[14]; char component[20]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index 63ee6d6d8..bc87f9344 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -12,14 +12,6 @@ ALGEBRAIC_COUNT = 0 EXTERNAL_COUNT = 3 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - EXTERNAL = 3 - - CONSTANT_INFO = [ ] @@ -30,9 +22,9 @@ class VariableType(Enum): ] EXTERNAL_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.EXTERNAL}, - {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.EXTERNAL}, - {"name": "z", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.EXTERNAL} + {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "z", "units": "dimensionless", "component": "my_algebraic_system"} ] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index 4cebe90c9..feb3430ed 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -13,18 +13,18 @@ const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 3; const VariableInfo CONSTANT_INFO[] = { - {"x", "dimensionless", "my_algebraic_system", CONSTANT}, - {"y", "dimensionless", "my_algebraic_system", CONSTANT} + {"x", "dimensionless", "my_algebraic_system"}, + {"y", "dimensionless", "my_algebraic_system"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT} + {"a", "dimensionless", "my_algebraic_system"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"d", "dimensionless", "my_algebraic_system", ALGEBRAIC}, - {"b", "dimensionless", "my_algebraic_system", ALGEBRAIC}, - {"c", "dimensionless", "my_algebraic_system", ALGEBRAIC} + {"d", "dimensionless", "my_algebraic_system"}, + {"b", "dimensionless", "my_algebraic_system"}, + {"c", "dimensionless", "my_algebraic_system"} }; double * createVariablesArray() diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index 6633bbe21..a8b4dbbcc 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -11,17 +11,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[20]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 4c2a52ea3..4c438c3f1 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -11,26 +11,19 @@ COMPUTED_CONSTANT_COUNT = 1 ALGEBRAIC_COUNT = 3 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - - CONSTANT_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT}, - {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT} + {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "a", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.COMPUTED_CONSTANT} + {"name": "a", "units": "dimensionless", "component": "my_algebraic_system"} ] ALGEBRAIC_INFO = [ - {"name": "d", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, - {"name": "b", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, - {"name": "c", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC} + {"name": "d", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "b", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "c", "units": "dimensionless", "component": "my_algebraic_system"} ] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index bb02166a7..48ed210ad 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -13,18 +13,18 @@ const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 3; const VariableInfo CONSTANT_INFO[] = { - {"x", "dimensionless", "my_algebraic_system", CONSTANT}, - {"y", "dimensionless", "my_algebraic_system", CONSTANT} + {"x", "dimensionless", "my_algebraic_system"}, + {"y", "dimensionless", "my_algebraic_system"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"a", "dimensionless", "my_algebraic_system", COMPUTED_CONSTANT} + {"a", "dimensionless", "my_algebraic_system"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"c", "dimensionless", "my_algebraic_system", ALGEBRAIC}, - {"b", "dimensionless", "my_algebraic_system", ALGEBRAIC}, - {"d", "dimensionless", "my_algebraic_system", ALGEBRAIC} + {"c", "dimensionless", "my_algebraic_system"}, + {"b", "dimensionless", "my_algebraic_system"}, + {"d", "dimensionless", "my_algebraic_system"} }; double * createVariablesArray() diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index 6633bbe21..a8b4dbbcc 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -11,17 +11,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[20]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 232ab46ef..d58855d92 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -11,26 +11,19 @@ COMPUTED_CONSTANT_COUNT = 1 ALGEBRAIC_COUNT = 3 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - - CONSTANT_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT}, - {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.CONSTANT} + {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "a", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.COMPUTED_CONSTANT} + {"name": "a", "units": "dimensionless", "component": "my_algebraic_system"} ] ALGEBRAIC_INFO = [ - {"name": "c", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, - {"name": "b", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, - {"name": "d", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC} + {"name": "c", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "b", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "d", "units": "dimensionless", "component": "my_algebraic_system"} ] diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index d53d3e1fd..8bfb7a585 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -16,8 +16,8 @@ const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"x", "dimensionless", "my_component", COMPUTED_CONSTANT}, - {"y", "dimensionless", "my_component", COMPUTED_CONSTANT} + {"x", "dimensionless", "my_component"}, + {"y", "dimensionless", "my_component"} }; const VariableInfo ALGEBRAIC_INFO[] = { diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index 2e7b0dd0b..c22b33894 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -11,17 +11,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[13]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 9b2aca671..0740ee0de 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -11,19 +11,12 @@ COMPUTED_CONSTANT_COUNT = 2 ALGEBRAIC_COUNT = 0 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - - CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "y", "units": "dimensionless", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} + {"name": "x", "units": "dimensionless", "component": "my_component"}, + {"name": "y", "units": "dimensionless", "component": "my_component"} ] ALGEBRAIC_INFO = [ diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index 48d3bfc77..a4bb58334 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -13,13 +13,13 @@ const size_t COMPUTED_CONSTANT_COUNT = 2; const size_t ALGEBRAIC_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { - {"L", "centimeter", "cell_geometry", CONSTANT}, - {"rad", "centimeter", "cell_geometry", CONSTANT} + {"L", "centimeter", "cell_geometry"}, + {"rad", "centimeter", "cell_geometry"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"vcell", "microlitre", "cell_geometry", COMPUTED_CONSTANT}, - {"vss", "microlitre", "cell_geometry", COMPUTED_CONSTANT} + {"vcell", "microlitre", "cell_geometry"}, + {"vss", "microlitre", "cell_geometry"} }; const VariableInfo ALGEBRAIC_INFO[] = { diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 1ca71d6f6..7a5964bc5 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -20,13 +20,13 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"vcell", "microlitre", "cell_geometry", ALGEBRAIC}, - {"vss", "microlitre", "cell_geometry", ALGEBRAIC} + {"vcell", "microlitre", "cell_geometry"}, + {"vss", "microlitre", "cell_geometry"} }; const VariableInfo EXTERNAL_INFO[] = { - {"L", "centimeter", "cell_geometry", EXTERNAL}, - {"rad", "centimeter", "cell_geometry", EXTERNAL} + {"L", "centimeter", "cell_geometry"}, + {"rad", "centimeter", "cell_geometry"} }; double * createVariablesArray() diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 84cfc4521..36d3e1822 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -12,18 +12,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[6]; char units[11]; char component[14]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 15e494636..aa3d00363 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -12,14 +12,6 @@ ALGEBRAIC_COUNT = 2 EXTERNAL_COUNT = 2 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - EXTERNAL = 3 - - CONSTANT_INFO = [ ] @@ -27,13 +19,13 @@ class VariableType(Enum): ] ALGEBRAIC_INFO = [ - {"name": "vcell", "units": "microlitre", "component": "cell_geometry", "type": VariableType.ALGEBRAIC}, - {"name": "vss", "units": "microlitre", "component": "cell_geometry", "type": VariableType.ALGEBRAIC} + {"name": "vcell", "units": "microlitre", "component": "cell_geometry"}, + {"name": "vss", "units": "microlitre", "component": "cell_geometry"} ] EXTERNAL_INFO = [ - {"name": "L", "units": "centimeter", "component": "cell_geometry", "type": VariableType.EXTERNAL}, - {"name": "rad", "units": "centimeter", "component": "cell_geometry", "type": VariableType.EXTERNAL} + {"name": "L", "units": "centimeter", "component": "cell_geometry"}, + {"name": "rad", "units": "centimeter", "component": "cell_geometry"} ] diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index 9dc3b9499..687403023 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -11,17 +11,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[6]; char units[11]; char component[14]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index 1ef05bded..4ba53cbcc 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -11,21 +11,14 @@ COMPUTED_CONSTANT_COUNT = 2 ALGEBRAIC_COUNT = 0 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - - CONSTANT_INFO = [ - {"name": "L", "units": "centimeter", "component": "cell_geometry", "type": VariableType.CONSTANT}, - {"name": "rad", "units": "centimeter", "component": "cell_geometry", "type": VariableType.CONSTANT} + {"name": "L", "units": "centimeter", "component": "cell_geometry"}, + {"name": "rad", "units": "centimeter", "component": "cell_geometry"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "vcell", "units": "microlitre", "component": "cell_geometry", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "vss", "units": "microlitre", "component": "cell_geometry", "type": VariableType.COMPUTED_CONSTANT} + {"name": "vcell", "units": "microlitre", "component": "cell_geometry"}, + {"name": "vss", "units": "microlitre", "component": "cell_geometry"} ] ALGEBRAIC_INFO = [ diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index f304992cb..5bb0dea81 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -13,11 +13,11 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; -const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "ms", "environment"}; const VariableInfo STATE_INFO[] = { - {"y", "mM", "circle_y_implementation", STATE}, - {"x", "mM", "circle_x", STATE} + {"y", "mM", "circle_y_implementation"}, + {"x", "mM", "circle_x"} }; const VariableInfo CONSTANT_INFO[] = { @@ -27,8 +27,8 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"local_complex_maths", "mM", "circle_sibling", ALGEBRAIC}, - {"two_x", "milli_mole", "circle_x_sibling", ALGEBRAIC} + {"local_complex_maths", "mM", "circle_sibling"}, + {"two_x", "milli_mole", "circle_x_sibling"} }; double * createStatesArray() diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index 9719caec0..ad9e483ac 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[20]; char units[11]; char component[24]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 745325178..21fd05b38 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -12,19 +12,10 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "y", "units": "mM", "component": "circle_y_implementation", "type": VariableType.STATE}, - {"name": "x", "units": "mM", "component": "circle_x", "type": VariableType.STATE} +STATE_INFO = {"name": "y", "units": "mM", "component": "circle_y_implementation"}, + {"name": "x", "units": "mM", "component": "circle_x"} CONSTANT_INFO = [ @@ -34,8 +25,8 @@ class VariableType(Enum): ] ALGEBRAIC_INFO = [ - {"name": "local_complex_maths", "units": "mM", "component": "circle_sibling", "type": VariableType.ALGEBRAIC}, - {"name": "two_x", "units": "milli_mole", "component": "circle_x_sibling", "type": VariableType.ALGEBRAIC} + {"name": "local_complex_maths", "units": "mM", "component": "circle_sibling"}, + {"name": "two_x", "units": "milli_mole", "component": "circle_x_sibling"} ] diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index cf83a2261..e75683666 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -11,27 +11,20 @@ COMPUTED_CONSTANT_COUNT = 1 ALGEBRAIC_COUNT = 0 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - - CONSTANT_INFO = [ - {"name": "E", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "q_Ao", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_1", "units": "per_fmol_sec4", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "q_Ai", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_2", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT} + {"name": "E", "units": "fmol", "component": "SLC_template3_ss"}, + {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, + {"name": "q_Ao", "units": "fmol", "component": "SLC_template3_ss"}, + {"name": "P_1", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, + {"name": "q_Ai", "units": "fmol", "component": "SLC_template3_ss"}, + {"name": "P_2", "units": "per_fmol_sec3", "component": "SLC_template3_ss"}, + {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss"}, + {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss"}, + {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "v", "units": "fmol_per_sec", "component": "SLC_template3_ss", "type": VariableType.COMPUTED_CONSTANT} + {"name": "v", "units": "fmol_per_sec", "component": "SLC_template3_ss"} ] ALGEBRAIC_INFO = [ diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index cf52db26b..074a5a21b 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -13,14 +13,14 @@ const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "ms", "environment"}; const VariableInfo STATE_INFO[] = { - {"x", "mV", "main", STATE} + {"x", "mV", "main"} }; const VariableInfo CONSTANT_INFO[] = { - {"k", "mV", "constants", CONSTANT} + {"k", "mV", "constants"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index 420928348..b05828f9b 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[3]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index f32c24fe0..0a0aa2864 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -12,22 +12,13 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "mV", "component": "main", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "mV", "component": "main"} CONSTANT_INFO = [ - {"name": "k", "units": "mV", "component": "constants", "type": VariableType.CONSTANT} + {"name": "k", "units": "mV", "component": "constants"} ] COMPUTED_CONSTANT_INFO = [ diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index a3494f54d..cabb1e728 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -13,12 +13,12 @@ const size_t COMPUTED_CONSTANT_COUNT = 2; const size_t ALGEBRAIC_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { - {"k", "mM", "constants", CONSTANT} + {"k", "mM", "constants"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"x", "mM", "main", COMPUTED_CONSTANT}, - {"y", "M", "main", COMPUTED_CONSTANT} + {"x", "mM", "main"}, + {"y", "M", "main"} }; const VariableInfo ALGEBRAIC_INFO[] = { diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index 2e51e8fd1..1fff52ad9 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -11,17 +11,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[3]; char component[10]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index bc4e24cb4..02d595b20 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -11,20 +11,13 @@ COMPUTED_CONSTANT_COUNT = 2 ALGEBRAIC_COUNT = 0 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - - CONSTANT_INFO = [ - {"name": "k", "units": "mM", "component": "constants", "type": VariableType.CONSTANT} + {"name": "k", "units": "mM", "component": "constants"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "x", "units": "mM", "component": "main", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "y", "units": "M", "component": "main", "type": VariableType.COMPUTED_CONSTANT} + {"name": "x", "units": "mM", "component": "main"}, + {"name": "y", "units": "M", "component": "main"} ] ALGEBRAIC_INFO = [ diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 302ea642f..c0529e1dc 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -13,10 +13,10 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; -const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "ms", "environment"}; const VariableInfo STATE_INFO[] = { - {"k", "mM", "states", STATE} + {"k", "mM", "states"} }; const VariableInfo CONSTANT_INFO[] = { @@ -26,8 +26,8 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"x", "mM", "main", ALGEBRAIC}, - {"y", "M", "main", ALGEBRAIC} + {"x", "mM", "main"}, + {"y", "M", "main"} }; double * createStatesArray() diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index 420928348..b05828f9b 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[3]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 4a031e253..536b041dd 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -12,18 +12,9 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "k", "units": "mM", "component": "states", "type": VariableType.STATE} +STATE_INFO = {"name": "k", "units": "mM", "component": "states"} CONSTANT_INFO = [ @@ -33,8 +24,8 @@ class VariableType(Enum): ] ALGEBRAIC_INFO = [ - {"name": "x", "units": "mM", "component": "main", "type": VariableType.ALGEBRAIC}, - {"name": "y", "units": "M", "component": "main", "type": VariableType.ALGEBRAIC} + {"name": "x", "units": "mM", "component": "main"}, + {"name": "y", "units": "M", "component": "main"} ] diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 550d7ad85..f2664b5fa 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -13,10 +13,10 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; -const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "ms", "environment"}; const VariableInfo STATE_INFO[] = { - {"k", "mM", "states", STATE} + {"k", "mM", "states"} }; const VariableInfo CONSTANT_INFO[] = { @@ -26,8 +26,8 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"x", "mM", "main", ALGEBRAIC}, - {"y", "M", "main", ALGEBRAIC} + {"x", "mM", "main"}, + {"y", "M", "main"} }; double * createStatesArray() diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index 420928348..b05828f9b 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[3]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index f5bfca28f..3a560fa48 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -12,18 +12,9 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "k", "units": "mM", "component": "states", "type": VariableType.STATE} +STATE_INFO = {"name": "k", "units": "mM", "component": "states"} CONSTANT_INFO = [ @@ -33,8 +24,8 @@ class VariableType(Enum): ] ALGEBRAIC_INFO = [ - {"name": "x", "units": "mM", "component": "main", "type": VariableType.ALGEBRAIC}, - {"name": "y", "units": "M", "component": "main", "type": VariableType.ALGEBRAIC} + {"name": "x", "units": "mM", "component": "main"}, + {"name": "y", "units": "M", "component": "main"} ] diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index 03bb266d5..94efa316a 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -13,11 +13,11 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "ms", "environment"}; const VariableInfo STATE_INFO[] = { - {"k1", "mM", "main", STATE}, - {"k2", "M", "main", STATE} + {"k1", "mM", "main"}, + {"k2", "M", "main"} }; const VariableInfo CONSTANT_INFO[] = { diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index 46d3f1cf8..b889cfc43 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[3]; char units[3]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index d3f5a756d..dce4e92ce 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -12,19 +12,10 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "k1", "units": "mM", "component": "main", "type": VariableType.STATE}, - {"name": "k2", "units": "M", "component": "main", "type": VariableType.STATE} +STATE_INFO = {"name": "k1", "units": "mM", "component": "main"}, + {"name": "k2", "units": "M", "component": "main"} CONSTANT_INFO = [ diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index 2cb41fddf..52c79b1c7 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -13,16 +13,16 @@ const size_t CONSTANT_COUNT = 2; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "ms", "environment"}; const VariableInfo STATE_INFO[] = { - {"k1", "mM", "main", STATE}, - {"k2", "M", "main", STATE} + {"k1", "mM", "main"}, + {"k2", "M", "main"} }; const VariableInfo CONSTANT_INFO[] = { - {"k1_cst", "mM", "constants", CONSTANT}, - {"k2_cst", "mM", "constants", CONSTANT} + {"k1_cst", "mM", "constants"}, + {"k2_cst", "mM", "constants"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index ef9422431..59b9535ec 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[7]; char units[3]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 0ad4df919..98b669a5f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -12,24 +12,15 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "k1", "units": "mM", "component": "main", "type": VariableType.STATE}, - {"name": "k2", "units": "M", "component": "main", "type": VariableType.STATE} +STATE_INFO = {"name": "k1", "units": "mM", "component": "main"}, + {"name": "k2", "units": "M", "component": "main"} CONSTANT_INFO = [ - {"name": "k1_cst", "units": "mM", "component": "constants", "type": VariableType.CONSTANT}, - {"name": "k2_cst", "units": "mM", "component": "constants", "type": VariableType.CONSTANT} + {"name": "k1_cst", "units": "mM", "component": "constants"}, + {"name": "k2_cst", "units": "mM", "component": "constants"} ] COMPUTED_CONSTANT_INFO = [ diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index f29503e6a..63f8794d1 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -13,11 +13,11 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "ms", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "ms", "environment"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "main", STATE}, - {"y", "dimensionless", "main", STATE} + {"x", "dimensionless", "main"}, + {"y", "dimensionless", "main"} }; const VariableInfo CONSTANT_INFO[] = { diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index 35acb1470..8d446982d 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index f86e8920c..b8ff408e5 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -12,19 +12,10 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "ms", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "main", "type": VariableType.STATE}, - {"name": "y", "units": "dimensionless", "component": "main", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "main"}, + {"name": "y", "units": "dimensionless", "component": "main"} CONSTANT_INFO = [ diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index 05950cf51..d3b8f3522 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -13,12 +13,12 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"x", "metre", "t_in_s", STATE}, - {"x", "metre", "t_in_ms", STATE}, - {"x", "metre", "t_in_ks", STATE} + {"x", "metre", "t_in_s"}, + {"x", "metre", "t_in_ms"}, + {"x", "metre", "t_in_ks"} }; const VariableInfo CONSTANT_INFO[] = { diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index ce44fd3c1..749c14ce7 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[7]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index 751996429..c651290c6 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -12,20 +12,11 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "metre", "component": "t_in_s", "type": VariableType.STATE}, - {"name": "x", "units": "metre", "component": "t_in_ms", "type": VariableType.STATE}, - {"name": "x", "units": "metre", "component": "t_in_ks", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "metre", "component": "t_in_s"}, + {"name": "x", "units": "metre", "component": "t_in_ms"}, + {"name": "x", "units": "metre", "component": "t_in_ks"} CONSTANT_INFO = [ diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index c35d824f1..1ebd5e5fb 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -13,30 +13,30 @@ const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 5; -const VariableInfo VOI_INFO = {"t", "second", "main", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "main"}; const VariableInfo STATE_INFO[] = { - {"q_1", "coulomb", "main", STATE}, - {"v_3", "C_per_s", "main", STATE} + {"q_1", "coulomb", "main"}, + {"v_3", "C_per_s", "main"} }; const VariableInfo CONSTANT_INFO[] = { - {"v_in", "C_per_s", "main", CONSTANT}, - {"v_out", "C_per_s", "main", CONSTANT}, - {"C", "C2_per_J", "main", CONSTANT}, - {"R", "Js_per_C2", "main", CONSTANT}, - {"L", "Js2_per_C2", "main", CONSTANT} + {"v_in", "C_per_s", "main"}, + {"v_out", "C_per_s", "main"}, + {"C", "C2_per_J", "main"}, + {"R", "Js_per_C2", "main"}, + {"L", "Js2_per_C2", "main"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"v_1", "C_per_s", "main", ALGEBRAIC}, - {"v_2", "C_per_s", "main", ALGEBRAIC}, - {"u_1", "J_per_C", "main", ALGEBRAIC}, - {"u_2", "J_per_C", "main", ALGEBRAIC}, - {"u_3", "J_per_C", "main", ALGEBRAIC} + {"v_1", "C_per_s", "main"}, + {"v_2", "C_per_s", "main"}, + {"u_1", "J_per_C", "main"}, + {"u_2", "J_per_C", "main"}, + {"u_3", "J_per_C", "main"} }; double * createStatesArray() diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 8ebd938f3..b6b9e63d2 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[6]; char units[11]; char component[5]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 3c39a8b8c..ec7692c38 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -12,38 +12,29 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 5 +VOI_INFO = {"name": "t", "units": "second", "component": "main"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "main", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "q_1", "units": "coulomb", "component": "main", "type": VariableType.STATE}, - {"name": "v_3", "units": "C_per_s", "component": "main", "type": VariableType.STATE} +STATE_INFO = {"name": "q_1", "units": "coulomb", "component": "main"}, + {"name": "v_3", "units": "C_per_s", "component": "main"} CONSTANT_INFO = [ - {"name": "v_in", "units": "C_per_s", "component": "main", "type": VariableType.CONSTANT}, - {"name": "v_out", "units": "C_per_s", "component": "main", "type": VariableType.CONSTANT}, - {"name": "C", "units": "C2_per_J", "component": "main", "type": VariableType.CONSTANT}, - {"name": "R", "units": "Js_per_C2", "component": "main", "type": VariableType.CONSTANT}, - {"name": "L", "units": "Js2_per_C2", "component": "main", "type": VariableType.CONSTANT} + {"name": "v_in", "units": "C_per_s", "component": "main"}, + {"name": "v_out", "units": "C_per_s", "component": "main"}, + {"name": "C", "units": "C2_per_J", "component": "main"}, + {"name": "R", "units": "Js_per_C2", "component": "main"}, + {"name": "L", "units": "Js2_per_C2", "component": "main"} ] COMPUTED_CONSTANT_INFO = [ ] ALGEBRAIC_INFO = [ - {"name": "v_1", "units": "C_per_s", "component": "main", "type": VariableType.ALGEBRAIC}, - {"name": "v_2", "units": "C_per_s", "component": "main", "type": VariableType.ALGEBRAIC}, - {"name": "u_1", "units": "J_per_C", "component": "main", "type": VariableType.ALGEBRAIC}, - {"name": "u_2", "units": "J_per_C", "component": "main", "type": VariableType.ALGEBRAIC}, - {"name": "u_3", "units": "J_per_C", "component": "main", "type": VariableType.ALGEBRAIC} + {"name": "v_1", "units": "C_per_s", "component": "main"}, + {"name": "v_2", "units": "C_per_s", "component": "main"}, + {"name": "u_1", "units": "J_per_C", "component": "main"}, + {"name": "u_2", "units": "J_per_C", "component": "main"}, + {"name": "u_3", "units": "J_per_C", "component": "main"} ] diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 796c72dbf..abaa47ae6 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -13,10 +13,10 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; -const VariableInfo VOI_INFO = {"time", "second", "my_component", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "second", "my_component"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_component", STATE} + {"x", "dimensionless", "my_component"} }; const VariableInfo CONSTANT_INFO[] = { @@ -26,8 +26,8 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"a", "second", "my_component", ALGEBRAIC}, - {"b", "second", "my_component", ALGEBRAIC} + {"a", "second", "my_component"}, + {"b", "second", "my_component"} }; double * createStatesArray() diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 3e6d21a18..31a196c76 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[5]; char units[14]; char component[13]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index 98091ed39..a2d3b99f8 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -12,18 +12,9 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +VOI_INFO = {"name": "time", "units": "second", "component": "my_component"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "time", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} CONSTANT_INFO = [ @@ -33,8 +24,8 @@ class VariableType(Enum): ] ALGEBRAIC_INFO = [ - {"name": "a", "units": "second", "component": "my_component", "type": VariableType.ALGEBRAIC}, - {"name": "b", "units": "second", "component": "my_component", "type": VariableType.ALGEBRAIC} + {"name": "a", "units": "second", "component": "my_component"}, + {"name": "b", "units": "second", "component": "my_component"} ] diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 51bfd4d93..a382c211b 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -13,268 +13,268 @@ const size_t CONSTANT_COUNT = 91; const size_t COMPUTED_CONSTANT_COUNT = 25; const size_t ALGEBRAIC_COUNT = 101; -const VariableInfo VOI_INFO = {"time", "second", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"Ca_sub", "millimolar", "Ca_dynamics", STATE}, - {"Nai_", "millimolar", "Nai_concentration", STATE}, - {"Ca_jsr", "millimolar", "Ca_dynamics", STATE}, - {"O", "dimensionless", "Ca_SR_release", STATE}, - {"R", "dimensionless", "Ca_SR_release", STATE}, - {"RI", "dimensionless", "Ca_SR_release", STATE}, - {"I", "dimensionless", "Ca_SR_release", STATE}, - {"Cai", "millimolar", "Ca_dynamics", STATE}, - {"Ca_nsr", "millimolar", "Ca_dynamics", STATE}, - {"fTC", "dimensionless", "Ca_buffering", STATE}, - {"fTMC", "dimensionless", "Ca_buffering", STATE}, - {"fTMM", "dimensionless", "Ca_buffering", STATE}, - {"fCMi", "dimensionless", "Ca_buffering", STATE}, - {"fCMs", "dimensionless", "Ca_buffering", STATE}, - {"fCQ", "dimensionless", "Ca_buffering", STATE}, - {"V_ode", "millivolt", "Membrane", STATE}, - {"y", "dimensionless", "i_f_y_gate", STATE}, - {"h", "dimensionless", "i_Na_h_gate", STATE}, - {"m", "dimensionless", "i_Na_m_gate", STATE}, - {"s_Kur", "dimensionless", "i_Kur_sKur_gate", STATE}, - {"r_Kur", "dimensionless", "i_Kur_rKur_gate", STATE}, - {"fCa", "dimensionless", "i_CaL_fCa_gate", STATE}, - {"fL", "dimensionless", "i_CaL_fL_gate", STATE}, - {"dL", "dimensionless", "i_CaL_dL_gate", STATE}, - {"fT", "dimensionless", "i_CaT_fT_gate", STATE}, - {"dT", "dimensionless", "i_CaT_dT_gate", STATE}, - {"r", "dimensionless", "i_to_r_gate", STATE}, - {"q", "dimensionless", "i_to_q_gate", STATE}, - {"piy", "dimensionless", "i_Kr_pi_gate", STATE}, - {"paF", "dimensionless", "i_Kr_pa_gate", STATE}, - {"paS", "dimensionless", "i_Kr_pa_gate", STATE}, - {"n", "dimensionless", "i_Ks_n_gate", STATE}, - {"a", "dimensionless", "i_KACh_a_gate", STATE} + {"Ca_sub", "millimolar", "Ca_dynamics"}, + {"Nai_", "millimolar", "Nai_concentration"}, + {"Ca_jsr", "millimolar", "Ca_dynamics"}, + {"O", "dimensionless", "Ca_SR_release"}, + {"R", "dimensionless", "Ca_SR_release"}, + {"RI", "dimensionless", "Ca_SR_release"}, + {"I", "dimensionless", "Ca_SR_release"}, + {"Cai", "millimolar", "Ca_dynamics"}, + {"Ca_nsr", "millimolar", "Ca_dynamics"}, + {"fTC", "dimensionless", "Ca_buffering"}, + {"fTMC", "dimensionless", "Ca_buffering"}, + {"fTMM", "dimensionless", "Ca_buffering"}, + {"fCMi", "dimensionless", "Ca_buffering"}, + {"fCMs", "dimensionless", "Ca_buffering"}, + {"fCQ", "dimensionless", "Ca_buffering"}, + {"V_ode", "millivolt", "Membrane"}, + {"y", "dimensionless", "i_f_y_gate"}, + {"h", "dimensionless", "i_Na_h_gate"}, + {"m", "dimensionless", "i_Na_m_gate"}, + {"s_Kur", "dimensionless", "i_Kur_sKur_gate"}, + {"r_Kur", "dimensionless", "i_Kur_rKur_gate"}, + {"fCa", "dimensionless", "i_CaL_fCa_gate"}, + {"fL", "dimensionless", "i_CaL_fL_gate"}, + {"dL", "dimensionless", "i_CaL_dL_gate"}, + {"fT", "dimensionless", "i_CaT_fT_gate"}, + {"dT", "dimensionless", "i_CaT_dT_gate"}, + {"r", "dimensionless", "i_to_r_gate"}, + {"q", "dimensionless", "i_to_q_gate"}, + {"piy", "dimensionless", "i_Kr_pi_gate"}, + {"paF", "dimensionless", "i_Kr_pa_gate"}, + {"paS", "dimensionless", "i_Kr_pa_gate"}, + {"n", "dimensionless", "i_Ks_n_gate"}, + {"a", "dimensionless", "i_KACh_a_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"ACh", "millimolar", "Rate_modulation_experiments", CONSTANT}, - {"Iso_1_uM", "dimensionless", "Rate_modulation_experiments", CONSTANT}, - {"Nao", "millimolar", "Ionic_values", CONSTANT}, - {"Ko", "millimolar", "Ionic_values", CONSTANT}, - {"Ki", "millimolar", "Ionic_values", CONSTANT}, - {"Cao", "millimolar", "Ionic_values", CONSTANT}, - {"Nai_clamp", "dimensionless", "Nai_concentration", CONSTANT}, - {"F", "coulomb_per_mole", "Membrane", CONSTANT}, - {"Km_Nap", "millimolar", "i_NaK", CONSTANT}, - {"Km_Kp", "millimolar", "i_NaK", CONSTANT}, - {"i_NaK_max", "nanoA", "i_NaK", CONSTANT}, - {"blockade_NaCa", "dimensionless", "i_NaCa", CONSTANT}, - {"K_NaCa", "nanoA", "i_NaCa", CONSTANT}, - {"K3ni", "millimolar", "i_NaCa", CONSTANT}, - {"Kci", "millimolar", "i_NaCa", CONSTANT}, - {"Qci", "dimensionless", "i_NaCa", CONSTANT}, - {"K1ni", "millimolar", "i_NaCa", CONSTANT}, - {"K2ni", "millimolar", "i_NaCa", CONSTANT}, - {"Qn", "dimensionless", "i_NaCa", CONSTANT}, - {"Kcni", "millimolar", "i_NaCa", CONSTANT}, - {"K3no", "millimolar", "i_NaCa", CONSTANT}, - {"Kco", "millimolar", "i_NaCa", CONSTANT}, - {"Qco", "dimensionless", "i_NaCa", CONSTANT}, - {"K1no", "millimolar", "i_NaCa", CONSTANT}, - {"K2no", "millimolar", "i_NaCa", CONSTANT}, - {"ks", "per_second", "Ca_SR_release", CONSTANT}, - {"MaxSR", "dimensionless", "Ca_SR_release", CONSTANT}, - {"MinSR", "dimensionless", "Ca_SR_release", CONSTANT}, - {"EC50_SR", "millimolar", "Ca_SR_release", CONSTANT}, - {"HSR", "dimensionless", "Ca_SR_release", CONSTANT}, - {"koCa", "per_millimolar2_second", "Ca_SR_release", CONSTANT}, - {"kiCa", "per_millimolar_second", "Ca_SR_release", CONSTANT}, - {"kim", "per_second", "Ca_SR_release", CONSTANT}, - {"kom", "per_second", "Ca_SR_release", CONSTANT}, - {"P_up_basal", "millimolar_per_second", "Ca_intracellular_fluxes", CONSTANT}, - {"tau_dif_Ca", "second", "Ca_intracellular_fluxes", CONSTANT}, - {"K_up", "millimolar", "Ca_intracellular_fluxes", CONSTANT}, - {"slope_up", "millimolar", "Ca_intracellular_fluxes", CONSTANT}, - {"tau_tr", "second", "Ca_intracellular_fluxes", CONSTANT}, - {"kf_TC", "per_millimolar_second", "Ca_buffering", CONSTANT}, - {"kb_TC", "per_second", "Ca_buffering", CONSTANT}, - {"kf_TMC", "per_millimolar_second", "Ca_buffering", CONSTANT}, - {"kb_TMC", "per_second", "Ca_buffering", CONSTANT}, - {"kf_TMM", "per_millimolar_second", "Ca_buffering", CONSTANT}, - {"Mgi", "millimolar", "Ca_buffering", CONSTANT}, - {"kb_TMM", "per_second", "Ca_buffering", CONSTANT}, - {"kf_CM", "per_millimolar_second", "Ca_buffering", CONSTANT}, - {"kb_CM", "per_second", "Ca_buffering", CONSTANT}, - {"kf_CQ", "per_millimolar_second", "Ca_buffering", CONSTANT}, - {"kb_CQ", "per_second", "Ca_buffering", CONSTANT}, - {"TC_tot", "millimolar", "Ca_buffering", CONSTANT}, - {"TMC_tot", "millimolar", "Ca_buffering", CONSTANT}, - {"CM_tot", "millimolar", "Ca_buffering", CONSTANT}, - {"CQ_tot", "millimolar", "Ca_buffering", CONSTANT}, - {"L_cell", "micrometre", "Cell_parameters", CONSTANT}, - {"R_cell", "micrometre", "Cell_parameters", CONSTANT}, - {"L_sub", "micrometre", "Cell_parameters", CONSTANT}, - {"V_jsr_part", "dimensionless", "Cell_parameters", CONSTANT}, - {"V_i_part", "dimensionless", "Cell_parameters", CONSTANT}, - {"V_nsr_part", "dimensionless", "Cell_parameters", CONSTANT}, - {"C", "microF", "Membrane", CONSTANT}, - {"R", "joule_per_kilomole_kelvin", "Membrane", CONSTANT}, - {"T", "kelvin", "Membrane", CONSTANT}, - {"clamp_mode", "dimensionless", "Membrane", CONSTANT}, - {"V_test", "millivolt", "Voltage_clamp", CONSTANT}, - {"t_holding", "second", "Voltage_clamp", CONSTANT}, - {"t_test", "second", "Voltage_clamp", CONSTANT}, - {"V_holding", "millivolt", "Voltage_clamp", CONSTANT}, - {"g_f", "microS", "i_f", CONSTANT}, - {"Km_f", "millimolar", "i_f", CONSTANT}, - {"alpha", "dimensionless", "i_f", CONSTANT}, - {"blockade", "dimensionless", "i_f", CONSTANT}, - {"y_shift", "millivolt", "i_f_y_gate", CONSTANT}, - {"g_Na", "microS", "i_Na", CONSTANT}, - {"g_Na_L", "microS", "i_Na", CONSTANT}, - {"delta_m", "millivolt", "i_Na_m_gate", CONSTANT}, - {"g_Kur", "microS", "i_Kur", CONSTANT}, - {"P_CaL", "nanoA_per_millimolar", "i_CaL", CONSTANT}, - {"V_dL", "millivolt", "i_CaL_dL_gate", CONSTANT}, - {"k_dL", "millivolt", "i_CaL_dL_gate", CONSTANT}, - {"shift_fL", "millivolt", "i_CaL_fL_gate", CONSTANT}, - {"k_fL", "millivolt", "i_CaL_fL_gate", CONSTANT}, - {"Km_fCa", "millimolar", "i_CaL_fCa_gate", CONSTANT}, - {"alpha_fCa", "per_second", "i_CaL_fCa_gate", CONSTANT}, - {"P_CaT", "nanoA_per_millimolar", "i_CaT", CONSTANT}, - {"offset_fT", "second", "i_CaT_fT_gate", CONSTANT}, - {"g_to", "microS", "i_to", CONSTANT}, - {"g_Kr", "microS", "i_Kr", CONSTANT}, - {"g_Ks_", "microS", "i_Ks", CONSTANT}, - {"ACh_on", "dimensionless", "i_KACh", CONSTANT}, - {"g_KACh", "microS", "i_KACh", CONSTANT} + {"ACh", "millimolar", "Rate_modulation_experiments"}, + {"Iso_1_uM", "dimensionless", "Rate_modulation_experiments"}, + {"Nao", "millimolar", "Ionic_values"}, + {"Ko", "millimolar", "Ionic_values"}, + {"Ki", "millimolar", "Ionic_values"}, + {"Cao", "millimolar", "Ionic_values"}, + {"Nai_clamp", "dimensionless", "Nai_concentration"}, + {"F", "coulomb_per_mole", "Membrane"}, + {"Km_Nap", "millimolar", "i_NaK"}, + {"Km_Kp", "millimolar", "i_NaK"}, + {"i_NaK_max", "nanoA", "i_NaK"}, + {"blockade_NaCa", "dimensionless", "i_NaCa"}, + {"K_NaCa", "nanoA", "i_NaCa"}, + {"K3ni", "millimolar", "i_NaCa"}, + {"Kci", "millimolar", "i_NaCa"}, + {"Qci", "dimensionless", "i_NaCa"}, + {"K1ni", "millimolar", "i_NaCa"}, + {"K2ni", "millimolar", "i_NaCa"}, + {"Qn", "dimensionless", "i_NaCa"}, + {"Kcni", "millimolar", "i_NaCa"}, + {"K3no", "millimolar", "i_NaCa"}, + {"Kco", "millimolar", "i_NaCa"}, + {"Qco", "dimensionless", "i_NaCa"}, + {"K1no", "millimolar", "i_NaCa"}, + {"K2no", "millimolar", "i_NaCa"}, + {"ks", "per_second", "Ca_SR_release"}, + {"MaxSR", "dimensionless", "Ca_SR_release"}, + {"MinSR", "dimensionless", "Ca_SR_release"}, + {"EC50_SR", "millimolar", "Ca_SR_release"}, + {"HSR", "dimensionless", "Ca_SR_release"}, + {"koCa", "per_millimolar2_second", "Ca_SR_release"}, + {"kiCa", "per_millimolar_second", "Ca_SR_release"}, + {"kim", "per_second", "Ca_SR_release"}, + {"kom", "per_second", "Ca_SR_release"}, + {"P_up_basal", "millimolar_per_second", "Ca_intracellular_fluxes"}, + {"tau_dif_Ca", "second", "Ca_intracellular_fluxes"}, + {"K_up", "millimolar", "Ca_intracellular_fluxes"}, + {"slope_up", "millimolar", "Ca_intracellular_fluxes"}, + {"tau_tr", "second", "Ca_intracellular_fluxes"}, + {"kf_TC", "per_millimolar_second", "Ca_buffering"}, + {"kb_TC", "per_second", "Ca_buffering"}, + {"kf_TMC", "per_millimolar_second", "Ca_buffering"}, + {"kb_TMC", "per_second", "Ca_buffering"}, + {"kf_TMM", "per_millimolar_second", "Ca_buffering"}, + {"Mgi", "millimolar", "Ca_buffering"}, + {"kb_TMM", "per_second", "Ca_buffering"}, + {"kf_CM", "per_millimolar_second", "Ca_buffering"}, + {"kb_CM", "per_second", "Ca_buffering"}, + {"kf_CQ", "per_millimolar_second", "Ca_buffering"}, + {"kb_CQ", "per_second", "Ca_buffering"}, + {"TC_tot", "millimolar", "Ca_buffering"}, + {"TMC_tot", "millimolar", "Ca_buffering"}, + {"CM_tot", "millimolar", "Ca_buffering"}, + {"CQ_tot", "millimolar", "Ca_buffering"}, + {"L_cell", "micrometre", "Cell_parameters"}, + {"R_cell", "micrometre", "Cell_parameters"}, + {"L_sub", "micrometre", "Cell_parameters"}, + {"V_jsr_part", "dimensionless", "Cell_parameters"}, + {"V_i_part", "dimensionless", "Cell_parameters"}, + {"V_nsr_part", "dimensionless", "Cell_parameters"}, + {"C", "microF", "Membrane"}, + {"R", "joule_per_kilomole_kelvin", "Membrane"}, + {"T", "kelvin", "Membrane"}, + {"clamp_mode", "dimensionless", "Membrane"}, + {"V_test", "millivolt", "Voltage_clamp"}, + {"t_holding", "second", "Voltage_clamp"}, + {"t_test", "second", "Voltage_clamp"}, + {"V_holding", "millivolt", "Voltage_clamp"}, + {"g_f", "microS", "i_f"}, + {"Km_f", "millimolar", "i_f"}, + {"alpha", "dimensionless", "i_f"}, + {"blockade", "dimensionless", "i_f"}, + {"y_shift", "millivolt", "i_f_y_gate"}, + {"g_Na", "microS", "i_Na"}, + {"g_Na_L", "microS", "i_Na"}, + {"delta_m", "millivolt", "i_Na_m_gate"}, + {"g_Kur", "microS", "i_Kur"}, + {"P_CaL", "nanoA_per_millimolar", "i_CaL"}, + {"V_dL", "millivolt", "i_CaL_dL_gate"}, + {"k_dL", "millivolt", "i_CaL_dL_gate"}, + {"shift_fL", "millivolt", "i_CaL_fL_gate"}, + {"k_fL", "millivolt", "i_CaL_fL_gate"}, + {"Km_fCa", "millimolar", "i_CaL_fCa_gate"}, + {"alpha_fCa", "per_second", "i_CaL_fCa_gate"}, + {"P_CaT", "nanoA_per_millimolar", "i_CaT"}, + {"offset_fT", "second", "i_CaT_fT_gate"}, + {"g_to", "microS", "i_to"}, + {"g_Kr", "microS", "i_Kr"}, + {"g_Ks_", "microS", "i_Ks"}, + {"ACh_on", "dimensionless", "i_KACh"}, + {"g_KACh", "microS", "i_KACh"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"RTONF", "millivolt", "Membrane", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "Ionic_values", COMPUTED_CONSTANT}, - {"V_i", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, - {"V_sub", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, - {"Iso_increase", "dimensionless", "i_NaK", COMPUTED_CONSTANT}, - {"k34", "dimensionless", "i_NaCa", COMPUTED_CONSTANT}, - {"b_up", "dimensionless", "Ca_intracellular_fluxes", COMPUTED_CONSTANT}, - {"P_up", "millimolar_per_second", "Ca_intracellular_fluxes", COMPUTED_CONSTANT}, - {"V_nsr", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, - {"V_jsr", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, - {"V_cell", "millimetre3", "Cell_parameters", COMPUTED_CONSTANT}, - {"G_f", "microS", "i_f", COMPUTED_CONSTANT}, - {"G_f_K", "microS", "i_f", COMPUTED_CONSTANT}, - {"G_f_Na", "microS", "i_f", COMPUTED_CONSTANT}, - {"g_f_Na", "microS", "i_f", COMPUTED_CONSTANT}, - {"g_f_K", "microS", "i_f", COMPUTED_CONSTANT}, - {"ACh_shift", "millivolt", "i_f_y_gate", COMPUTED_CONSTANT}, - {"Iso_shift", "millivolt", "i_f_y_gate", COMPUTED_CONSTANT}, - {"Iso_increase", "dimensionless", "i_CaL", COMPUTED_CONSTANT}, - {"ACh_block", "dimensionless", "i_CaL", COMPUTED_CONSTANT}, - {"Iso_shift_dL", "millivolt", "i_CaL_dL_gate", COMPUTED_CONSTANT}, - {"Iso_slope_dL", "dimensionless", "i_CaL_dL_gate", COMPUTED_CONSTANT}, - {"g_Ks", "microS", "i_Ks", COMPUTED_CONSTANT}, - {"Iso_shift", "millivolt", "i_Ks_n_gate", COMPUTED_CONSTANT}, - {"alpha_a", "per_second", "i_KACh_a_gate", COMPUTED_CONSTANT} + {"RTONF", "millivolt", "Membrane"}, + {"E_K", "millivolt", "Ionic_values"}, + {"V_i", "millimetre3", "Cell_parameters"}, + {"V_sub", "millimetre3", "Cell_parameters"}, + {"Iso_increase", "dimensionless", "i_NaK"}, + {"k34", "dimensionless", "i_NaCa"}, + {"b_up", "dimensionless", "Ca_intracellular_fluxes"}, + {"P_up", "millimolar_per_second", "Ca_intracellular_fluxes"}, + {"V_nsr", "millimetre3", "Cell_parameters"}, + {"V_jsr", "millimetre3", "Cell_parameters"}, + {"V_cell", "millimetre3", "Cell_parameters"}, + {"G_f", "microS", "i_f"}, + {"G_f_K", "microS", "i_f"}, + {"G_f_Na", "microS", "i_f"}, + {"g_f_Na", "microS", "i_f"}, + {"g_f_K", "microS", "i_f"}, + {"ACh_shift", "millivolt", "i_f_y_gate"}, + {"Iso_shift", "millivolt", "i_f_y_gate"}, + {"Iso_increase", "dimensionless", "i_CaL"}, + {"ACh_block", "dimensionless", "i_CaL"}, + {"Iso_shift_dL", "millivolt", "i_CaL_dL_gate"}, + {"Iso_slope_dL", "dimensionless", "i_CaL_dL_gate"}, + {"g_Ks", "microS", "i_Ks"}, + {"Iso_shift", "millivolt", "i_Ks_n_gate"}, + {"alpha_a", "per_second", "i_KACh_a_gate"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"E_Na", "millivolt", "Ionic_values", ALGEBRAIC}, - {"Nai", "millimolar", "Nai_concentration", ALGEBRAIC}, - {"E_Ca", "millivolt", "Ionic_values", ALGEBRAIC}, - {"i_Na", "nanoA", "i_Na", ALGEBRAIC}, - {"i_NaCa", "nanoA", "i_NaCa", ALGEBRAIC}, - {"i_NaK", "nanoA", "i_NaK", ALGEBRAIC}, - {"i_siNa", "nanoA", "i_CaL", ALGEBRAIC}, - {"i_fNa", "nanoA", "i_f", ALGEBRAIC}, - {"V", "millivolt", "Membrane", ALGEBRAIC}, - {"x2", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k21", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"x1", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k12", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"x4", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"x3", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k41", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k23", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k43", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k32", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"k14", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"di", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"do", "dimensionless", "i_NaCa", ALGEBRAIC}, - {"j_SRCarel", "millimolar_per_second", "Ca_SR_release", ALGEBRAIC}, - {"diff", "millimolar", "Ca_SR_release", ALGEBRAIC}, - {"kCaSR", "dimensionless", "Ca_SR_release", ALGEBRAIC}, - {"koSRCa", "per_millimolar2_second", "Ca_SR_release", ALGEBRAIC}, - {"kiSRCa", "per_millimolar_second", "Ca_SR_release", ALGEBRAIC}, - {"P_tot", "dimensionless", "Ca_SR_release", ALGEBRAIC}, - {"j_Ca_dif", "millimolar_per_second", "Ca_intracellular_fluxes", ALGEBRAIC}, - {"j_up", "millimolar_per_second", "Ca_intracellular_fluxes", ALGEBRAIC}, - {"j_tr", "millimolar_per_second", "Ca_intracellular_fluxes", ALGEBRAIC}, - {"delta_fTC", "per_second", "Ca_buffering", ALGEBRAIC}, - {"delta_fTMC", "per_second", "Ca_buffering", ALGEBRAIC}, - {"delta_fTMM", "per_second", "Ca_buffering", ALGEBRAIC}, - {"delta_fCMi", "per_second", "Ca_buffering", ALGEBRAIC}, - {"delta_fCMs", "per_second", "Ca_buffering", ALGEBRAIC}, - {"delta_fCQ", "per_second", "Ca_buffering", ALGEBRAIC}, - {"i_siCa", "nanoA", "i_CaL", ALGEBRAIC}, - {"i_CaT", "nanoA", "i_CaT", ALGEBRAIC}, - {"i_tot", "nanoA", "Membrane", ALGEBRAIC}, - {"i_f", "nanoA", "i_f", ALGEBRAIC}, - {"i_Kur", "nanoA", "i_Kur", ALGEBRAIC}, - {"i_KACh", "nanoA", "i_KACh", ALGEBRAIC}, - {"i_CaL", "nanoA", "i_CaL", ALGEBRAIC}, - {"i_to", "nanoA", "i_to", ALGEBRAIC}, - {"i_Ks", "nanoA", "i_Ks", ALGEBRAIC}, - {"i_Kr", "nanoA", "i_Kr", ALGEBRAIC}, - {"V_clamp", "millivolt", "Voltage_clamp", ALGEBRAIC}, - {"i_fK", "nanoA", "i_f", ALGEBRAIC}, - {"tau_y", "second", "i_f_y_gate", ALGEBRAIC}, - {"y_infinity", "dimensionless", "i_f_y_gate", ALGEBRAIC}, - {"E_mh", "millivolt", "i_Na", ALGEBRAIC}, - {"i_Na_", "nanoA", "i_Na", ALGEBRAIC}, - {"i_Na_L", "nanoA", "i_Na", ALGEBRAIC}, - {"m_infinity", "dimensionless", "i_Na_m_gate", ALGEBRAIC}, - {"E0_m", "millivolt", "i_Na_m_gate", ALGEBRAIC}, - {"alpha_m", "per_second", "i_Na_m_gate", ALGEBRAIC}, - {"beta_m", "per_second", "i_Na_m_gate", ALGEBRAIC}, - {"tau_m", "second", "i_Na_m_gate", ALGEBRAIC}, - {"h_infinity", "dimensionless", "i_Na_h_gate", ALGEBRAIC}, - {"alpha_h", "per_second", "i_Na_h_gate", ALGEBRAIC}, - {"beta_h", "per_second", "i_Na_h_gate", ALGEBRAIC}, - {"tau_h", "second", "i_Na_h_gate", ALGEBRAIC}, - {"r_Kur_infinity", "dimensionless", "i_Kur_rKur_gate", ALGEBRAIC}, - {"tau_r_Kur", "second", "i_Kur_rKur_gate", ALGEBRAIC}, - {"s_Kur_infinity", "dimensionless", "i_Kur_sKur_gate", ALGEBRAIC}, - {"tau_s_Kur", "second", "i_Kur_sKur_gate", ALGEBRAIC}, - {"i_siK", "nanoA", "i_CaL", ALGEBRAIC}, - {"dL_infinity", "dimensionless", "i_CaL_dL_gate", ALGEBRAIC}, - {"tau_dL", "second", "i_CaL_dL_gate", ALGEBRAIC}, - {"alpha_dL", "per_second", "i_CaL_dL_gate", ALGEBRAIC}, - {"beta_dL", "per_second", "i_CaL_dL_gate", ALGEBRAIC}, - {"adVm", "millivolt", "i_CaL_dL_gate", ALGEBRAIC}, - {"bdVm", "millivolt", "i_CaL_dL_gate", ALGEBRAIC}, - {"fL_infinity", "dimensionless", "i_CaL_fL_gate", ALGEBRAIC}, - {"tau_fL", "second", "i_CaL_fL_gate", ALGEBRAIC}, - {"fCa_infinity", "dimensionless", "i_CaL_fCa_gate", ALGEBRAIC}, - {"tau_fCa", "second", "i_CaL_fCa_gate", ALGEBRAIC}, - {"dT_infinity", "dimensionless", "i_CaT_dT_gate", ALGEBRAIC}, - {"tau_dT", "second", "i_CaT_dT_gate", ALGEBRAIC}, - {"fT_infinity", "dimensionless", "i_CaT_fT_gate", ALGEBRAIC}, - {"tau_fT", "second", "i_CaT_fT_gate", ALGEBRAIC}, - {"q_infinity", "dimensionless", "i_to_q_gate", ALGEBRAIC}, - {"tau_q", "second", "i_to_q_gate", ALGEBRAIC}, - {"r_infinity", "dimensionless", "i_to_r_gate", ALGEBRAIC}, - {"tau_r", "second", "i_to_r_gate", ALGEBRAIC}, - {"alfapaF", "per_second", "i_Kr_pa_gate", ALGEBRAIC}, - {"betapaF", "per_second", "i_Kr_pa_gate", ALGEBRAIC}, - {"pa_infinity", "dimensionless", "i_Kr_pa_gate", ALGEBRAIC}, - {"tau_paS", "second", "i_Kr_pa_gate", ALGEBRAIC}, - {"tau_paF", "second", "i_Kr_pa_gate", ALGEBRAIC}, - {"tau_pi", "second", "i_Kr_pi_gate", ALGEBRAIC}, - {"pi_infinity", "dimensionless", "i_Kr_pi_gate", ALGEBRAIC}, - {"E_Ks", "millivolt", "i_Ks", ALGEBRAIC}, - {"n_infinity", "dimensionless", "i_Ks_n_gate", ALGEBRAIC}, - {"tau_n", "second", "i_Ks_n_gate", ALGEBRAIC}, - {"alpha_n", "per_second", "i_Ks_n_gate", ALGEBRAIC}, - {"beta_n", "per_second", "i_Ks_n_gate", ALGEBRAIC}, - {"beta_a", "per_second", "i_KACh_a_gate", ALGEBRAIC}, - {"a_infinity", "dimensionless", "i_KACh_a_gate", ALGEBRAIC}, - {"tau_a", "second", "i_KACh_a_gate", ALGEBRAIC} + {"E_Na", "millivolt", "Ionic_values"}, + {"Nai", "millimolar", "Nai_concentration"}, + {"E_Ca", "millivolt", "Ionic_values"}, + {"i_Na", "nanoA", "i_Na"}, + {"i_NaCa", "nanoA", "i_NaCa"}, + {"i_NaK", "nanoA", "i_NaK"}, + {"i_siNa", "nanoA", "i_CaL"}, + {"i_fNa", "nanoA", "i_f"}, + {"V", "millivolt", "Membrane"}, + {"x2", "dimensionless", "i_NaCa"}, + {"k21", "dimensionless", "i_NaCa"}, + {"x1", "dimensionless", "i_NaCa"}, + {"k12", "dimensionless", "i_NaCa"}, + {"x4", "dimensionless", "i_NaCa"}, + {"x3", "dimensionless", "i_NaCa"}, + {"k41", "dimensionless", "i_NaCa"}, + {"k23", "dimensionless", "i_NaCa"}, + {"k43", "dimensionless", "i_NaCa"}, + {"k32", "dimensionless", "i_NaCa"}, + {"k14", "dimensionless", "i_NaCa"}, + {"di", "dimensionless", "i_NaCa"}, + {"do", "dimensionless", "i_NaCa"}, + {"j_SRCarel", "millimolar_per_second", "Ca_SR_release"}, + {"diff", "millimolar", "Ca_SR_release"}, + {"kCaSR", "dimensionless", "Ca_SR_release"}, + {"koSRCa", "per_millimolar2_second", "Ca_SR_release"}, + {"kiSRCa", "per_millimolar_second", "Ca_SR_release"}, + {"P_tot", "dimensionless", "Ca_SR_release"}, + {"j_Ca_dif", "millimolar_per_second", "Ca_intracellular_fluxes"}, + {"j_up", "millimolar_per_second", "Ca_intracellular_fluxes"}, + {"j_tr", "millimolar_per_second", "Ca_intracellular_fluxes"}, + {"delta_fTC", "per_second", "Ca_buffering"}, + {"delta_fTMC", "per_second", "Ca_buffering"}, + {"delta_fTMM", "per_second", "Ca_buffering"}, + {"delta_fCMi", "per_second", "Ca_buffering"}, + {"delta_fCMs", "per_second", "Ca_buffering"}, + {"delta_fCQ", "per_second", "Ca_buffering"}, + {"i_siCa", "nanoA", "i_CaL"}, + {"i_CaT", "nanoA", "i_CaT"}, + {"i_tot", "nanoA", "Membrane"}, + {"i_f", "nanoA", "i_f"}, + {"i_Kur", "nanoA", "i_Kur"}, + {"i_KACh", "nanoA", "i_KACh"}, + {"i_CaL", "nanoA", "i_CaL"}, + {"i_to", "nanoA", "i_to"}, + {"i_Ks", "nanoA", "i_Ks"}, + {"i_Kr", "nanoA", "i_Kr"}, + {"V_clamp", "millivolt", "Voltage_clamp"}, + {"i_fK", "nanoA", "i_f"}, + {"tau_y", "second", "i_f_y_gate"}, + {"y_infinity", "dimensionless", "i_f_y_gate"}, + {"E_mh", "millivolt", "i_Na"}, + {"i_Na_", "nanoA", "i_Na"}, + {"i_Na_L", "nanoA", "i_Na"}, + {"m_infinity", "dimensionless", "i_Na_m_gate"}, + {"E0_m", "millivolt", "i_Na_m_gate"}, + {"alpha_m", "per_second", "i_Na_m_gate"}, + {"beta_m", "per_second", "i_Na_m_gate"}, + {"tau_m", "second", "i_Na_m_gate"}, + {"h_infinity", "dimensionless", "i_Na_h_gate"}, + {"alpha_h", "per_second", "i_Na_h_gate"}, + {"beta_h", "per_second", "i_Na_h_gate"}, + {"tau_h", "second", "i_Na_h_gate"}, + {"r_Kur_infinity", "dimensionless", "i_Kur_rKur_gate"}, + {"tau_r_Kur", "second", "i_Kur_rKur_gate"}, + {"s_Kur_infinity", "dimensionless", "i_Kur_sKur_gate"}, + {"tau_s_Kur", "second", "i_Kur_sKur_gate"}, + {"i_siK", "nanoA", "i_CaL"}, + {"dL_infinity", "dimensionless", "i_CaL_dL_gate"}, + {"tau_dL", "second", "i_CaL_dL_gate"}, + {"alpha_dL", "per_second", "i_CaL_dL_gate"}, + {"beta_dL", "per_second", "i_CaL_dL_gate"}, + {"adVm", "millivolt", "i_CaL_dL_gate"}, + {"bdVm", "millivolt", "i_CaL_dL_gate"}, + {"fL_infinity", "dimensionless", "i_CaL_fL_gate"}, + {"tau_fL", "second", "i_CaL_fL_gate"}, + {"fCa_infinity", "dimensionless", "i_CaL_fCa_gate"}, + {"tau_fCa", "second", "i_CaL_fCa_gate"}, + {"dT_infinity", "dimensionless", "i_CaT_dT_gate"}, + {"tau_dT", "second", "i_CaT_dT_gate"}, + {"fT_infinity", "dimensionless", "i_CaT_fT_gate"}, + {"tau_fT", "second", "i_CaT_fT_gate"}, + {"q_infinity", "dimensionless", "i_to_q_gate"}, + {"tau_q", "second", "i_to_q_gate"}, + {"r_infinity", "dimensionless", "i_to_r_gate"}, + {"tau_r", "second", "i_to_r_gate"}, + {"alfapaF", "per_second", "i_Kr_pa_gate"}, + {"betapaF", "per_second", "i_Kr_pa_gate"}, + {"pa_infinity", "dimensionless", "i_Kr_pa_gate"}, + {"tau_paS", "second", "i_Kr_pa_gate"}, + {"tau_paF", "second", "i_Kr_pa_gate"}, + {"tau_pi", "second", "i_Kr_pi_gate"}, + {"pi_infinity", "dimensionless", "i_Kr_pi_gate"}, + {"E_Ks", "millivolt", "i_Ks"}, + {"n_infinity", "dimensionless", "i_Ks_n_gate"}, + {"tau_n", "second", "i_Ks_n_gate"}, + {"alpha_n", "per_second", "i_Ks_n_gate"}, + {"beta_n", "per_second", "i_Ks_n_gate"}, + {"beta_a", "per_second", "i_KACh_a_gate"}, + {"a_infinity", "dimensionless", "i_KACh_a_gate"}, + {"tau_a", "second", "i_KACh_a_gate"} }; double * createStatesArray() diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 1fee5d4d2..72b9004c1 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[15]; char units[26]; char component[28]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index ef40ae85f..41c323410 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -12,276 +12,267 @@ COMPUTED_CONSTANT_COUNT = 25 ALGEBRAIC_COUNT = 101 - -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "time", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "Ca_sub", "units": "millimolar", "component": "Ca_dynamics", "type": VariableType.STATE}, - {"name": "Nai_", "units": "millimolar", "component": "Nai_concentration", "type": VariableType.STATE}, - {"name": "Ca_jsr", "units": "millimolar", "component": "Ca_dynamics", "type": VariableType.STATE}, - {"name": "O", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.STATE}, - {"name": "R", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.STATE}, - {"name": "RI", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.STATE}, - {"name": "I", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.STATE}, - {"name": "Cai", "units": "millimolar", "component": "Ca_dynamics", "type": VariableType.STATE}, - {"name": "Ca_nsr", "units": "millimolar", "component": "Ca_dynamics", "type": VariableType.STATE}, - {"name": "fTC", "units": "dimensionless", "component": "Ca_buffering", "type": VariableType.STATE}, - {"name": "fTMC", "units": "dimensionless", "component": "Ca_buffering", "type": VariableType.STATE}, - {"name": "fTMM", "units": "dimensionless", "component": "Ca_buffering", "type": VariableType.STATE}, - {"name": "fCMi", "units": "dimensionless", "component": "Ca_buffering", "type": VariableType.STATE}, - {"name": "fCMs", "units": "dimensionless", "component": "Ca_buffering", "type": VariableType.STATE}, - {"name": "fCQ", "units": "dimensionless", "component": "Ca_buffering", "type": VariableType.STATE}, - {"name": "V_ode", "units": "millivolt", "component": "Membrane", "type": VariableType.STATE}, - {"name": "y", "units": "dimensionless", "component": "i_f_y_gate", "type": VariableType.STATE}, - {"name": "h", "units": "dimensionless", "component": "i_Na_h_gate", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "i_Na_m_gate", "type": VariableType.STATE}, - {"name": "s_Kur", "units": "dimensionless", "component": "i_Kur_sKur_gate", "type": VariableType.STATE}, - {"name": "r_Kur", "units": "dimensionless", "component": "i_Kur_rKur_gate", "type": VariableType.STATE}, - {"name": "fCa", "units": "dimensionless", "component": "i_CaL_fCa_gate", "type": VariableType.STATE}, - {"name": "fL", "units": "dimensionless", "component": "i_CaL_fL_gate", "type": VariableType.STATE}, - {"name": "dL", "units": "dimensionless", "component": "i_CaL_dL_gate", "type": VariableType.STATE}, - {"name": "fT", "units": "dimensionless", "component": "i_CaT_fT_gate", "type": VariableType.STATE}, - {"name": "dT", "units": "dimensionless", "component": "i_CaT_dT_gate", "type": VariableType.STATE}, - {"name": "r", "units": "dimensionless", "component": "i_to_r_gate", "type": VariableType.STATE}, - {"name": "q", "units": "dimensionless", "component": "i_to_q_gate", "type": VariableType.STATE}, - {"name": "piy", "units": "dimensionless", "component": "i_Kr_pi_gate", "type": VariableType.STATE}, - {"name": "paF", "units": "dimensionless", "component": "i_Kr_pa_gate", "type": VariableType.STATE}, - {"name": "paS", "units": "dimensionless", "component": "i_Kr_pa_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "i_Ks_n_gate", "type": VariableType.STATE}, - {"name": "a", "units": "dimensionless", "component": "i_KACh_a_gate", "type": VariableType.STATE} +VOI_INFO = {"name": "time", "units": "second", "component": "environment"} + +STATE_INFO = {"name": "Ca_sub", "units": "millimolar", "component": "Ca_dynamics"}, + {"name": "Nai_", "units": "millimolar", "component": "Nai_concentration"}, + {"name": "Ca_jsr", "units": "millimolar", "component": "Ca_dynamics"}, + {"name": "O", "units": "dimensionless", "component": "Ca_SR_release"}, + {"name": "R", "units": "dimensionless", "component": "Ca_SR_release"}, + {"name": "RI", "units": "dimensionless", "component": "Ca_SR_release"}, + {"name": "I", "units": "dimensionless", "component": "Ca_SR_release"}, + {"name": "Cai", "units": "millimolar", "component": "Ca_dynamics"}, + {"name": "Ca_nsr", "units": "millimolar", "component": "Ca_dynamics"}, + {"name": "fTC", "units": "dimensionless", "component": "Ca_buffering"}, + {"name": "fTMC", "units": "dimensionless", "component": "Ca_buffering"}, + {"name": "fTMM", "units": "dimensionless", "component": "Ca_buffering"}, + {"name": "fCMi", "units": "dimensionless", "component": "Ca_buffering"}, + {"name": "fCMs", "units": "dimensionless", "component": "Ca_buffering"}, + {"name": "fCQ", "units": "dimensionless", "component": "Ca_buffering"}, + {"name": "V_ode", "units": "millivolt", "component": "Membrane"}, + {"name": "y", "units": "dimensionless", "component": "i_f_y_gate"}, + {"name": "h", "units": "dimensionless", "component": "i_Na_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "i_Na_m_gate"}, + {"name": "s_Kur", "units": "dimensionless", "component": "i_Kur_sKur_gate"}, + {"name": "r_Kur", "units": "dimensionless", "component": "i_Kur_rKur_gate"}, + {"name": "fCa", "units": "dimensionless", "component": "i_CaL_fCa_gate"}, + {"name": "fL", "units": "dimensionless", "component": "i_CaL_fL_gate"}, + {"name": "dL", "units": "dimensionless", "component": "i_CaL_dL_gate"}, + {"name": "fT", "units": "dimensionless", "component": "i_CaT_fT_gate"}, + {"name": "dT", "units": "dimensionless", "component": "i_CaT_dT_gate"}, + {"name": "r", "units": "dimensionless", "component": "i_to_r_gate"}, + {"name": "q", "units": "dimensionless", "component": "i_to_q_gate"}, + {"name": "piy", "units": "dimensionless", "component": "i_Kr_pi_gate"}, + {"name": "paF", "units": "dimensionless", "component": "i_Kr_pa_gate"}, + {"name": "paS", "units": "dimensionless", "component": "i_Kr_pa_gate"}, + {"name": "n", "units": "dimensionless", "component": "i_Ks_n_gate"}, + {"name": "a", "units": "dimensionless", "component": "i_KACh_a_gate"} CONSTANT_INFO = [ - {"name": "ACh", "units": "millimolar", "component": "Rate_modulation_experiments", "type": VariableType.CONSTANT}, - {"name": "Iso_1_uM", "units": "dimensionless", "component": "Rate_modulation_experiments", "type": VariableType.CONSTANT}, - {"name": "Nao", "units": "millimolar", "component": "Ionic_values", "type": VariableType.CONSTANT}, - {"name": "Ko", "units": "millimolar", "component": "Ionic_values", "type": VariableType.CONSTANT}, - {"name": "Ki", "units": "millimolar", "component": "Ionic_values", "type": VariableType.CONSTANT}, - {"name": "Cao", "units": "millimolar", "component": "Ionic_values", "type": VariableType.CONSTANT}, - {"name": "Nai_clamp", "units": "dimensionless", "component": "Nai_concentration", "type": VariableType.CONSTANT}, - {"name": "F", "units": "coulomb_per_mole", "component": "Membrane", "type": VariableType.CONSTANT}, - {"name": "Km_Nap", "units": "millimolar", "component": "i_NaK", "type": VariableType.CONSTANT}, - {"name": "Km_Kp", "units": "millimolar", "component": "i_NaK", "type": VariableType.CONSTANT}, - {"name": "i_NaK_max", "units": "nanoA", "component": "i_NaK", "type": VariableType.CONSTANT}, - {"name": "blockade_NaCa", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "K_NaCa", "units": "nanoA", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "K3ni", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "Kci", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "Qci", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "K1ni", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "K2ni", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "Qn", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "Kcni", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "K3no", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "Kco", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "Qco", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "K1no", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "K2no", "units": "millimolar", "component": "i_NaCa", "type": VariableType.CONSTANT}, - {"name": "ks", "units": "per_second", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "MaxSR", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "MinSR", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "EC50_SR", "units": "millimolar", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "HSR", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "koCa", "units": "per_millimolar2_second", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "kiCa", "units": "per_millimolar_second", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "kim", "units": "per_second", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "kom", "units": "per_second", "component": "Ca_SR_release", "type": VariableType.CONSTANT}, - {"name": "P_up_basal", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.CONSTANT}, - {"name": "tau_dif_Ca", "units": "second", "component": "Ca_intracellular_fluxes", "type": VariableType.CONSTANT}, - {"name": "K_up", "units": "millimolar", "component": "Ca_intracellular_fluxes", "type": VariableType.CONSTANT}, - {"name": "slope_up", "units": "millimolar", "component": "Ca_intracellular_fluxes", "type": VariableType.CONSTANT}, - {"name": "tau_tr", "units": "second", "component": "Ca_intracellular_fluxes", "type": VariableType.CONSTANT}, - {"name": "kf_TC", "units": "per_millimolar_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "kb_TC", "units": "per_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "kf_TMC", "units": "per_millimolar_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "kb_TMC", "units": "per_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "kf_TMM", "units": "per_millimolar_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "Mgi", "units": "millimolar", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "kb_TMM", "units": "per_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "kf_CM", "units": "per_millimolar_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "kb_CM", "units": "per_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "kf_CQ", "units": "per_millimolar_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "kb_CQ", "units": "per_second", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "TC_tot", "units": "millimolar", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "TMC_tot", "units": "millimolar", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "CM_tot", "units": "millimolar", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "CQ_tot", "units": "millimolar", "component": "Ca_buffering", "type": VariableType.CONSTANT}, - {"name": "L_cell", "units": "micrometre", "component": "Cell_parameters", "type": VariableType.CONSTANT}, - {"name": "R_cell", "units": "micrometre", "component": "Cell_parameters", "type": VariableType.CONSTANT}, - {"name": "L_sub", "units": "micrometre", "component": "Cell_parameters", "type": VariableType.CONSTANT}, - {"name": "V_jsr_part", "units": "dimensionless", "component": "Cell_parameters", "type": VariableType.CONSTANT}, - {"name": "V_i_part", "units": "dimensionless", "component": "Cell_parameters", "type": VariableType.CONSTANT}, - {"name": "V_nsr_part", "units": "dimensionless", "component": "Cell_parameters", "type": VariableType.CONSTANT}, - {"name": "C", "units": "microF", "component": "Membrane", "type": VariableType.CONSTANT}, - {"name": "R", "units": "joule_per_kilomole_kelvin", "component": "Membrane", "type": VariableType.CONSTANT}, - {"name": "T", "units": "kelvin", "component": "Membrane", "type": VariableType.CONSTANT}, - {"name": "clamp_mode", "units": "dimensionless", "component": "Membrane", "type": VariableType.CONSTANT}, - {"name": "V_test", "units": "millivolt", "component": "Voltage_clamp", "type": VariableType.CONSTANT}, - {"name": "t_holding", "units": "second", "component": "Voltage_clamp", "type": VariableType.CONSTANT}, - {"name": "t_test", "units": "second", "component": "Voltage_clamp", "type": VariableType.CONSTANT}, - {"name": "V_holding", "units": "millivolt", "component": "Voltage_clamp", "type": VariableType.CONSTANT}, - {"name": "g_f", "units": "microS", "component": "i_f", "type": VariableType.CONSTANT}, - {"name": "Km_f", "units": "millimolar", "component": "i_f", "type": VariableType.CONSTANT}, - {"name": "alpha", "units": "dimensionless", "component": "i_f", "type": VariableType.CONSTANT}, - {"name": "blockade", "units": "dimensionless", "component": "i_f", "type": VariableType.CONSTANT}, - {"name": "y_shift", "units": "millivolt", "component": "i_f_y_gate", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "microS", "component": "i_Na", "type": VariableType.CONSTANT}, - {"name": "g_Na_L", "units": "microS", "component": "i_Na", "type": VariableType.CONSTANT}, - {"name": "delta_m", "units": "millivolt", "component": "i_Na_m_gate", "type": VariableType.CONSTANT}, - {"name": "g_Kur", "units": "microS", "component": "i_Kur", "type": VariableType.CONSTANT}, - {"name": "P_CaL", "units": "nanoA_per_millimolar", "component": "i_CaL", "type": VariableType.CONSTANT}, - {"name": "V_dL", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.CONSTANT}, - {"name": "k_dL", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.CONSTANT}, - {"name": "shift_fL", "units": "millivolt", "component": "i_CaL_fL_gate", "type": VariableType.CONSTANT}, - {"name": "k_fL", "units": "millivolt", "component": "i_CaL_fL_gate", "type": VariableType.CONSTANT}, - {"name": "Km_fCa", "units": "millimolar", "component": "i_CaL_fCa_gate", "type": VariableType.CONSTANT}, - {"name": "alpha_fCa", "units": "per_second", "component": "i_CaL_fCa_gate", "type": VariableType.CONSTANT}, - {"name": "P_CaT", "units": "nanoA_per_millimolar", "component": "i_CaT", "type": VariableType.CONSTANT}, - {"name": "offset_fT", "units": "second", "component": "i_CaT_fT_gate", "type": VariableType.CONSTANT}, - {"name": "g_to", "units": "microS", "component": "i_to", "type": VariableType.CONSTANT}, - {"name": "g_Kr", "units": "microS", "component": "i_Kr", "type": VariableType.CONSTANT}, - {"name": "g_Ks_", "units": "microS", "component": "i_Ks", "type": VariableType.CONSTANT}, - {"name": "ACh_on", "units": "dimensionless", "component": "i_KACh", "type": VariableType.CONSTANT}, - {"name": "g_KACh", "units": "microS", "component": "i_KACh", "type": VariableType.CONSTANT} + {"name": "ACh", "units": "millimolar", "component": "Rate_modulation_experiments"}, + {"name": "Iso_1_uM", "units": "dimensionless", "component": "Rate_modulation_experiments"}, + {"name": "Nao", "units": "millimolar", "component": "Ionic_values"}, + {"name": "Ko", "units": "millimolar", "component": "Ionic_values"}, + {"name": "Ki", "units": "millimolar", "component": "Ionic_values"}, + {"name": "Cao", "units": "millimolar", "component": "Ionic_values"}, + {"name": "Nai_clamp", "units": "dimensionless", "component": "Nai_concentration"}, + {"name": "F", "units": "coulomb_per_mole", "component": "Membrane"}, + {"name": "Km_Nap", "units": "millimolar", "component": "i_NaK"}, + {"name": "Km_Kp", "units": "millimolar", "component": "i_NaK"}, + {"name": "i_NaK_max", "units": "nanoA", "component": "i_NaK"}, + {"name": "blockade_NaCa", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "K_NaCa", "units": "nanoA", "component": "i_NaCa"}, + {"name": "K3ni", "units": "millimolar", "component": "i_NaCa"}, + {"name": "Kci", "units": "millimolar", "component": "i_NaCa"}, + {"name": "Qci", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "K1ni", "units": "millimolar", "component": "i_NaCa"}, + {"name": "K2ni", "units": "millimolar", "component": "i_NaCa"}, + {"name": "Qn", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "Kcni", "units": "millimolar", "component": "i_NaCa"}, + {"name": "K3no", "units": "millimolar", "component": "i_NaCa"}, + {"name": "Kco", "units": "millimolar", "component": "i_NaCa"}, + {"name": "Qco", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "K1no", "units": "millimolar", "component": "i_NaCa"}, + {"name": "K2no", "units": "millimolar", "component": "i_NaCa"}, + {"name": "ks", "units": "per_second", "component": "Ca_SR_release"}, + {"name": "MaxSR", "units": "dimensionless", "component": "Ca_SR_release"}, + {"name": "MinSR", "units": "dimensionless", "component": "Ca_SR_release"}, + {"name": "EC50_SR", "units": "millimolar", "component": "Ca_SR_release"}, + {"name": "HSR", "units": "dimensionless", "component": "Ca_SR_release"}, + {"name": "koCa", "units": "per_millimolar2_second", "component": "Ca_SR_release"}, + {"name": "kiCa", "units": "per_millimolar_second", "component": "Ca_SR_release"}, + {"name": "kim", "units": "per_second", "component": "Ca_SR_release"}, + {"name": "kom", "units": "per_second", "component": "Ca_SR_release"}, + {"name": "P_up_basal", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes"}, + {"name": "tau_dif_Ca", "units": "second", "component": "Ca_intracellular_fluxes"}, + {"name": "K_up", "units": "millimolar", "component": "Ca_intracellular_fluxes"}, + {"name": "slope_up", "units": "millimolar", "component": "Ca_intracellular_fluxes"}, + {"name": "tau_tr", "units": "second", "component": "Ca_intracellular_fluxes"}, + {"name": "kf_TC", "units": "per_millimolar_second", "component": "Ca_buffering"}, + {"name": "kb_TC", "units": "per_second", "component": "Ca_buffering"}, + {"name": "kf_TMC", "units": "per_millimolar_second", "component": "Ca_buffering"}, + {"name": "kb_TMC", "units": "per_second", "component": "Ca_buffering"}, + {"name": "kf_TMM", "units": "per_millimolar_second", "component": "Ca_buffering"}, + {"name": "Mgi", "units": "millimolar", "component": "Ca_buffering"}, + {"name": "kb_TMM", "units": "per_second", "component": "Ca_buffering"}, + {"name": "kf_CM", "units": "per_millimolar_second", "component": "Ca_buffering"}, + {"name": "kb_CM", "units": "per_second", "component": "Ca_buffering"}, + {"name": "kf_CQ", "units": "per_millimolar_second", "component": "Ca_buffering"}, + {"name": "kb_CQ", "units": "per_second", "component": "Ca_buffering"}, + {"name": "TC_tot", "units": "millimolar", "component": "Ca_buffering"}, + {"name": "TMC_tot", "units": "millimolar", "component": "Ca_buffering"}, + {"name": "CM_tot", "units": "millimolar", "component": "Ca_buffering"}, + {"name": "CQ_tot", "units": "millimolar", "component": "Ca_buffering"}, + {"name": "L_cell", "units": "micrometre", "component": "Cell_parameters"}, + {"name": "R_cell", "units": "micrometre", "component": "Cell_parameters"}, + {"name": "L_sub", "units": "micrometre", "component": "Cell_parameters"}, + {"name": "V_jsr_part", "units": "dimensionless", "component": "Cell_parameters"}, + {"name": "V_i_part", "units": "dimensionless", "component": "Cell_parameters"}, + {"name": "V_nsr_part", "units": "dimensionless", "component": "Cell_parameters"}, + {"name": "C", "units": "microF", "component": "Membrane"}, + {"name": "R", "units": "joule_per_kilomole_kelvin", "component": "Membrane"}, + {"name": "T", "units": "kelvin", "component": "Membrane"}, + {"name": "clamp_mode", "units": "dimensionless", "component": "Membrane"}, + {"name": "V_test", "units": "millivolt", "component": "Voltage_clamp"}, + {"name": "t_holding", "units": "second", "component": "Voltage_clamp"}, + {"name": "t_test", "units": "second", "component": "Voltage_clamp"}, + {"name": "V_holding", "units": "millivolt", "component": "Voltage_clamp"}, + {"name": "g_f", "units": "microS", "component": "i_f"}, + {"name": "Km_f", "units": "millimolar", "component": "i_f"}, + {"name": "alpha", "units": "dimensionless", "component": "i_f"}, + {"name": "blockade", "units": "dimensionless", "component": "i_f"}, + {"name": "y_shift", "units": "millivolt", "component": "i_f_y_gate"}, + {"name": "g_Na", "units": "microS", "component": "i_Na"}, + {"name": "g_Na_L", "units": "microS", "component": "i_Na"}, + {"name": "delta_m", "units": "millivolt", "component": "i_Na_m_gate"}, + {"name": "g_Kur", "units": "microS", "component": "i_Kur"}, + {"name": "P_CaL", "units": "nanoA_per_millimolar", "component": "i_CaL"}, + {"name": "V_dL", "units": "millivolt", "component": "i_CaL_dL_gate"}, + {"name": "k_dL", "units": "millivolt", "component": "i_CaL_dL_gate"}, + {"name": "shift_fL", "units": "millivolt", "component": "i_CaL_fL_gate"}, + {"name": "k_fL", "units": "millivolt", "component": "i_CaL_fL_gate"}, + {"name": "Km_fCa", "units": "millimolar", "component": "i_CaL_fCa_gate"}, + {"name": "alpha_fCa", "units": "per_second", "component": "i_CaL_fCa_gate"}, + {"name": "P_CaT", "units": "nanoA_per_millimolar", "component": "i_CaT"}, + {"name": "offset_fT", "units": "second", "component": "i_CaT_fT_gate"}, + {"name": "g_to", "units": "microS", "component": "i_to"}, + {"name": "g_Kr", "units": "microS", "component": "i_Kr"}, + {"name": "g_Ks_", "units": "microS", "component": "i_Ks"}, + {"name": "ACh_on", "units": "dimensionless", "component": "i_KACh"}, + {"name": "g_KACh", "units": "microS", "component": "i_KACh"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "RTONF", "units": "millivolt", "component": "Membrane", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "Ionic_values", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "V_i", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "V_sub", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "Iso_increase", "units": "dimensionless", "component": "i_NaK", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "k34", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "b_up", "units": "dimensionless", "component": "Ca_intracellular_fluxes", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "P_up", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "V_nsr", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "V_jsr", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "V_cell", "units": "millimetre3", "component": "Cell_parameters", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "G_f", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "G_f_K", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "G_f_Na", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_f_Na", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_f_K", "units": "microS", "component": "i_f", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "ACh_shift", "units": "millivolt", "component": "i_f_y_gate", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "Iso_shift", "units": "millivolt", "component": "i_f_y_gate", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "Iso_increase", "units": "dimensionless", "component": "i_CaL", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "ACh_block", "units": "dimensionless", "component": "i_CaL", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "Iso_shift_dL", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "Iso_slope_dL", "units": "dimensionless", "component": "i_CaL_dL_gate", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_Ks", "units": "microS", "component": "i_Ks", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "Iso_shift", "units": "millivolt", "component": "i_Ks_n_gate", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "alpha_a", "units": "per_second", "component": "i_KACh_a_gate", "type": VariableType.COMPUTED_CONSTANT} + {"name": "RTONF", "units": "millivolt", "component": "Membrane"}, + {"name": "E_K", "units": "millivolt", "component": "Ionic_values"}, + {"name": "V_i", "units": "millimetre3", "component": "Cell_parameters"}, + {"name": "V_sub", "units": "millimetre3", "component": "Cell_parameters"}, + {"name": "Iso_increase", "units": "dimensionless", "component": "i_NaK"}, + {"name": "k34", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "b_up", "units": "dimensionless", "component": "Ca_intracellular_fluxes"}, + {"name": "P_up", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes"}, + {"name": "V_nsr", "units": "millimetre3", "component": "Cell_parameters"}, + {"name": "V_jsr", "units": "millimetre3", "component": "Cell_parameters"}, + {"name": "V_cell", "units": "millimetre3", "component": "Cell_parameters"}, + {"name": "G_f", "units": "microS", "component": "i_f"}, + {"name": "G_f_K", "units": "microS", "component": "i_f"}, + {"name": "G_f_Na", "units": "microS", "component": "i_f"}, + {"name": "g_f_Na", "units": "microS", "component": "i_f"}, + {"name": "g_f_K", "units": "microS", "component": "i_f"}, + {"name": "ACh_shift", "units": "millivolt", "component": "i_f_y_gate"}, + {"name": "Iso_shift", "units": "millivolt", "component": "i_f_y_gate"}, + {"name": "Iso_increase", "units": "dimensionless", "component": "i_CaL"}, + {"name": "ACh_block", "units": "dimensionless", "component": "i_CaL"}, + {"name": "Iso_shift_dL", "units": "millivolt", "component": "i_CaL_dL_gate"}, + {"name": "Iso_slope_dL", "units": "dimensionless", "component": "i_CaL_dL_gate"}, + {"name": "g_Ks", "units": "microS", "component": "i_Ks"}, + {"name": "Iso_shift", "units": "millivolt", "component": "i_Ks_n_gate"}, + {"name": "alpha_a", "units": "per_second", "component": "i_KACh_a_gate"} ] ALGEBRAIC_INFO = [ - {"name": "E_Na", "units": "millivolt", "component": "Ionic_values", "type": VariableType.ALGEBRAIC}, - {"name": "Nai", "units": "millimolar", "component": "Nai_concentration", "type": VariableType.ALGEBRAIC}, - {"name": "E_Ca", "units": "millivolt", "component": "Ionic_values", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "nanoA", "component": "i_Na", "type": VariableType.ALGEBRAIC}, - {"name": "i_NaCa", "units": "nanoA", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "i_NaK", "units": "nanoA", "component": "i_NaK", "type": VariableType.ALGEBRAIC}, - {"name": "i_siNa", "units": "nanoA", "component": "i_CaL", "type": VariableType.ALGEBRAIC}, - {"name": "i_fNa", "units": "nanoA", "component": "i_f", "type": VariableType.ALGEBRAIC}, - {"name": "V", "units": "millivolt", "component": "Membrane", "type": VariableType.ALGEBRAIC}, - {"name": "x2", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k21", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "x1", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k12", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "x4", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "x3", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k41", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k23", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k43", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k32", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "k14", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "di", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "do", "units": "dimensionless", "component": "i_NaCa", "type": VariableType.ALGEBRAIC}, - {"name": "j_SRCarel", "units": "millimolar_per_second", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, - {"name": "diff", "units": "millimolar", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, - {"name": "kCaSR", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, - {"name": "koSRCa", "units": "per_millimolar2_second", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, - {"name": "kiSRCa", "units": "per_millimolar_second", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, - {"name": "P_tot", "units": "dimensionless", "component": "Ca_SR_release", "type": VariableType.ALGEBRAIC}, - {"name": "j_Ca_dif", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.ALGEBRAIC}, - {"name": "j_up", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.ALGEBRAIC}, - {"name": "j_tr", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes", "type": VariableType.ALGEBRAIC}, - {"name": "delta_fTC", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, - {"name": "delta_fTMC", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, - {"name": "delta_fTMM", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, - {"name": "delta_fCMi", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, - {"name": "delta_fCMs", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, - {"name": "delta_fCQ", "units": "per_second", "component": "Ca_buffering", "type": VariableType.ALGEBRAIC}, - {"name": "i_siCa", "units": "nanoA", "component": "i_CaL", "type": VariableType.ALGEBRAIC}, - {"name": "i_CaT", "units": "nanoA", "component": "i_CaT", "type": VariableType.ALGEBRAIC}, - {"name": "i_tot", "units": "nanoA", "component": "Membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_f", "units": "nanoA", "component": "i_f", "type": VariableType.ALGEBRAIC}, - {"name": "i_Kur", "units": "nanoA", "component": "i_Kur", "type": VariableType.ALGEBRAIC}, - {"name": "i_KACh", "units": "nanoA", "component": "i_KACh", "type": VariableType.ALGEBRAIC}, - {"name": "i_CaL", "units": "nanoA", "component": "i_CaL", "type": VariableType.ALGEBRAIC}, - {"name": "i_to", "units": "nanoA", "component": "i_to", "type": VariableType.ALGEBRAIC}, - {"name": "i_Ks", "units": "nanoA", "component": "i_Ks", "type": VariableType.ALGEBRAIC}, - {"name": "i_Kr", "units": "nanoA", "component": "i_Kr", "type": VariableType.ALGEBRAIC}, - {"name": "V_clamp", "units": "millivolt", "component": "Voltage_clamp", "type": VariableType.ALGEBRAIC}, - {"name": "i_fK", "units": "nanoA", "component": "i_f", "type": VariableType.ALGEBRAIC}, - {"name": "tau_y", "units": "second", "component": "i_f_y_gate", "type": VariableType.ALGEBRAIC}, - {"name": "y_infinity", "units": "dimensionless", "component": "i_f_y_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_mh", "units": "millivolt", "component": "i_Na", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na_", "units": "nanoA", "component": "i_Na", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na_L", "units": "nanoA", "component": "i_Na", "type": VariableType.ALGEBRAIC}, - {"name": "m_infinity", "units": "dimensionless", "component": "i_Na_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E0_m", "units": "millivolt", "component": "i_Na_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_second", "component": "i_Na_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_second", "component": "i_Na_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_m", "units": "second", "component": "i_Na_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "h_infinity", "units": "dimensionless", "component": "i_Na_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_second", "component": "i_Na_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_second", "component": "i_Na_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_h", "units": "second", "component": "i_Na_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "r_Kur_infinity", "units": "dimensionless", "component": "i_Kur_rKur_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_r_Kur", "units": "second", "component": "i_Kur_rKur_gate", "type": VariableType.ALGEBRAIC}, - {"name": "s_Kur_infinity", "units": "dimensionless", "component": "i_Kur_sKur_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_s_Kur", "units": "second", "component": "i_Kur_sKur_gate", "type": VariableType.ALGEBRAIC}, - {"name": "i_siK", "units": "nanoA", "component": "i_CaL", "type": VariableType.ALGEBRAIC}, - {"name": "dL_infinity", "units": "dimensionless", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_dL", "units": "second", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_dL", "units": "per_second", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_dL", "units": "per_second", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, - {"name": "adVm", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, - {"name": "bdVm", "units": "millivolt", "component": "i_CaL_dL_gate", "type": VariableType.ALGEBRAIC}, - {"name": "fL_infinity", "units": "dimensionless", "component": "i_CaL_fL_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_fL", "units": "second", "component": "i_CaL_fL_gate", "type": VariableType.ALGEBRAIC}, - {"name": "fCa_infinity", "units": "dimensionless", "component": "i_CaL_fCa_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_fCa", "units": "second", "component": "i_CaL_fCa_gate", "type": VariableType.ALGEBRAIC}, - {"name": "dT_infinity", "units": "dimensionless", "component": "i_CaT_dT_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_dT", "units": "second", "component": "i_CaT_dT_gate", "type": VariableType.ALGEBRAIC}, - {"name": "fT_infinity", "units": "dimensionless", "component": "i_CaT_fT_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_fT", "units": "second", "component": "i_CaT_fT_gate", "type": VariableType.ALGEBRAIC}, - {"name": "q_infinity", "units": "dimensionless", "component": "i_to_q_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_q", "units": "second", "component": "i_to_q_gate", "type": VariableType.ALGEBRAIC}, - {"name": "r_infinity", "units": "dimensionless", "component": "i_to_r_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_r", "units": "second", "component": "i_to_r_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alfapaF", "units": "per_second", "component": "i_Kr_pa_gate", "type": VariableType.ALGEBRAIC}, - {"name": "betapaF", "units": "per_second", "component": "i_Kr_pa_gate", "type": VariableType.ALGEBRAIC}, - {"name": "pa_infinity", "units": "dimensionless", "component": "i_Kr_pa_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_paS", "units": "second", "component": "i_Kr_pa_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_paF", "units": "second", "component": "i_Kr_pa_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_pi", "units": "second", "component": "i_Kr_pi_gate", "type": VariableType.ALGEBRAIC}, - {"name": "pi_infinity", "units": "dimensionless", "component": "i_Kr_pi_gate", "type": VariableType.ALGEBRAIC}, - {"name": "E_Ks", "units": "millivolt", "component": "i_Ks", "type": VariableType.ALGEBRAIC}, - {"name": "n_infinity", "units": "dimensionless", "component": "i_Ks_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_n", "units": "second", "component": "i_Ks_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_second", "component": "i_Ks_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_second", "component": "i_Ks_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_a", "units": "per_second", "component": "i_KACh_a_gate", "type": VariableType.ALGEBRAIC}, - {"name": "a_infinity", "units": "dimensionless", "component": "i_KACh_a_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_a", "units": "second", "component": "i_KACh_a_gate", "type": VariableType.ALGEBRAIC} + {"name": "E_Na", "units": "millivolt", "component": "Ionic_values"}, + {"name": "Nai", "units": "millimolar", "component": "Nai_concentration"}, + {"name": "E_Ca", "units": "millivolt", "component": "Ionic_values"}, + {"name": "i_Na", "units": "nanoA", "component": "i_Na"}, + {"name": "i_NaCa", "units": "nanoA", "component": "i_NaCa"}, + {"name": "i_NaK", "units": "nanoA", "component": "i_NaK"}, + {"name": "i_siNa", "units": "nanoA", "component": "i_CaL"}, + {"name": "i_fNa", "units": "nanoA", "component": "i_f"}, + {"name": "V", "units": "millivolt", "component": "Membrane"}, + {"name": "x2", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "k21", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "x1", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "k12", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "x4", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "x3", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "k41", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "k23", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "k43", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "k32", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "k14", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "di", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "do", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "j_SRCarel", "units": "millimolar_per_second", "component": "Ca_SR_release"}, + {"name": "diff", "units": "millimolar", "component": "Ca_SR_release"}, + {"name": "kCaSR", "units": "dimensionless", "component": "Ca_SR_release"}, + {"name": "koSRCa", "units": "per_millimolar2_second", "component": "Ca_SR_release"}, + {"name": "kiSRCa", "units": "per_millimolar_second", "component": "Ca_SR_release"}, + {"name": "P_tot", "units": "dimensionless", "component": "Ca_SR_release"}, + {"name": "j_Ca_dif", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes"}, + {"name": "j_up", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes"}, + {"name": "j_tr", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes"}, + {"name": "delta_fTC", "units": "per_second", "component": "Ca_buffering"}, + {"name": "delta_fTMC", "units": "per_second", "component": "Ca_buffering"}, + {"name": "delta_fTMM", "units": "per_second", "component": "Ca_buffering"}, + {"name": "delta_fCMi", "units": "per_second", "component": "Ca_buffering"}, + {"name": "delta_fCMs", "units": "per_second", "component": "Ca_buffering"}, + {"name": "delta_fCQ", "units": "per_second", "component": "Ca_buffering"}, + {"name": "i_siCa", "units": "nanoA", "component": "i_CaL"}, + {"name": "i_CaT", "units": "nanoA", "component": "i_CaT"}, + {"name": "i_tot", "units": "nanoA", "component": "Membrane"}, + {"name": "i_f", "units": "nanoA", "component": "i_f"}, + {"name": "i_Kur", "units": "nanoA", "component": "i_Kur"}, + {"name": "i_KACh", "units": "nanoA", "component": "i_KACh"}, + {"name": "i_CaL", "units": "nanoA", "component": "i_CaL"}, + {"name": "i_to", "units": "nanoA", "component": "i_to"}, + {"name": "i_Ks", "units": "nanoA", "component": "i_Ks"}, + {"name": "i_Kr", "units": "nanoA", "component": "i_Kr"}, + {"name": "V_clamp", "units": "millivolt", "component": "Voltage_clamp"}, + {"name": "i_fK", "units": "nanoA", "component": "i_f"}, + {"name": "tau_y", "units": "second", "component": "i_f_y_gate"}, + {"name": "y_infinity", "units": "dimensionless", "component": "i_f_y_gate"}, + {"name": "E_mh", "units": "millivolt", "component": "i_Na"}, + {"name": "i_Na_", "units": "nanoA", "component": "i_Na"}, + {"name": "i_Na_L", "units": "nanoA", "component": "i_Na"}, + {"name": "m_infinity", "units": "dimensionless", "component": "i_Na_m_gate"}, + {"name": "E0_m", "units": "millivolt", "component": "i_Na_m_gate"}, + {"name": "alpha_m", "units": "per_second", "component": "i_Na_m_gate"}, + {"name": "beta_m", "units": "per_second", "component": "i_Na_m_gate"}, + {"name": "tau_m", "units": "second", "component": "i_Na_m_gate"}, + {"name": "h_infinity", "units": "dimensionless", "component": "i_Na_h_gate"}, + {"name": "alpha_h", "units": "per_second", "component": "i_Na_h_gate"}, + {"name": "beta_h", "units": "per_second", "component": "i_Na_h_gate"}, + {"name": "tau_h", "units": "second", "component": "i_Na_h_gate"}, + {"name": "r_Kur_infinity", "units": "dimensionless", "component": "i_Kur_rKur_gate"}, + {"name": "tau_r_Kur", "units": "second", "component": "i_Kur_rKur_gate"}, + {"name": "s_Kur_infinity", "units": "dimensionless", "component": "i_Kur_sKur_gate"}, + {"name": "tau_s_Kur", "units": "second", "component": "i_Kur_sKur_gate"}, + {"name": "i_siK", "units": "nanoA", "component": "i_CaL"}, + {"name": "dL_infinity", "units": "dimensionless", "component": "i_CaL_dL_gate"}, + {"name": "tau_dL", "units": "second", "component": "i_CaL_dL_gate"}, + {"name": "alpha_dL", "units": "per_second", "component": "i_CaL_dL_gate"}, + {"name": "beta_dL", "units": "per_second", "component": "i_CaL_dL_gate"}, + {"name": "adVm", "units": "millivolt", "component": "i_CaL_dL_gate"}, + {"name": "bdVm", "units": "millivolt", "component": "i_CaL_dL_gate"}, + {"name": "fL_infinity", "units": "dimensionless", "component": "i_CaL_fL_gate"}, + {"name": "tau_fL", "units": "second", "component": "i_CaL_fL_gate"}, + {"name": "fCa_infinity", "units": "dimensionless", "component": "i_CaL_fCa_gate"}, + {"name": "tau_fCa", "units": "second", "component": "i_CaL_fCa_gate"}, + {"name": "dT_infinity", "units": "dimensionless", "component": "i_CaT_dT_gate"}, + {"name": "tau_dT", "units": "second", "component": "i_CaT_dT_gate"}, + {"name": "fT_infinity", "units": "dimensionless", "component": "i_CaT_fT_gate"}, + {"name": "tau_fT", "units": "second", "component": "i_CaT_fT_gate"}, + {"name": "q_infinity", "units": "dimensionless", "component": "i_to_q_gate"}, + {"name": "tau_q", "units": "second", "component": "i_to_q_gate"}, + {"name": "r_infinity", "units": "dimensionless", "component": "i_to_r_gate"}, + {"name": "tau_r", "units": "second", "component": "i_to_r_gate"}, + {"name": "alfapaF", "units": "per_second", "component": "i_Kr_pa_gate"}, + {"name": "betapaF", "units": "per_second", "component": "i_Kr_pa_gate"}, + {"name": "pa_infinity", "units": "dimensionless", "component": "i_Kr_pa_gate"}, + {"name": "tau_paS", "units": "second", "component": "i_Kr_pa_gate"}, + {"name": "tau_paF", "units": "second", "component": "i_Kr_pa_gate"}, + {"name": "tau_pi", "units": "second", "component": "i_Kr_pi_gate"}, + {"name": "pi_infinity", "units": "dimensionless", "component": "i_Kr_pi_gate"}, + {"name": "E_Ks", "units": "millivolt", "component": "i_Ks"}, + {"name": "n_infinity", "units": "dimensionless", "component": "i_Ks_n_gate"}, + {"name": "tau_n", "units": "second", "component": "i_Ks_n_gate"}, + {"name": "alpha_n", "units": "per_second", "component": "i_Ks_n_gate"}, + {"name": "beta_n", "units": "per_second", "component": "i_Ks_n_gate"}, + {"name": "beta_a", "units": "per_second", "component": "i_KACh_a_gate"}, + {"name": "a_infinity", "units": "dimensionless", "component": "i_KACh_a_gate"}, + {"name": "tau_a", "units": "second", "component": "i_KACh_a_gate"} ] diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 7717d14f1..cd6dbc4de 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -13,218 +13,218 @@ const size_t CONSTANT_COUNT = 110; const size_t COMPUTED_CONSTANT_COUNT = 23; const size_t ALGEBRAIC_COUNT = 52; -const VariableInfo VOI_INFO = {"time", "second", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane", STATE}, - {"m", "dimensionless", "sodium_current_m_gate", STATE}, - {"h1", "dimensionless", "sodium_current_h_gate", STATE}, - {"h2", "dimensionless", "sodium_current_h_gate", STATE}, - {"f_L", "dimensionless", "L_type_Ca_channel_f_gate", STATE}, - {"d_L", "dimensionless", "L_type_Ca_channel_d_gate", STATE}, - {"f_T", "dimensionless", "T_type_Ca_channel_f_gate", STATE}, - {"d_T", "dimensionless", "T_type_Ca_channel_d_gate", STATE}, - {"r", "dimensionless", "four_AP_sensitive_currents_r_gate", STATE}, - {"q", "dimensionless", "four_AP_sensitive_currents_q_gate", STATE}, - {"P_i", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_i_gate", STATE}, - {"P_af", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_af_gate", STATE}, - {"P_as", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_as_gate", STATE}, - {"xs", "dimensionless", "slow_delayed_rectifying_potassium_current_xs_gate", STATE}, - {"y", "dimensionless", "hyperpolarisation_activated_current_y_gate", STATE} + {"V", "millivolt", "membrane"}, + {"m", "dimensionless", "sodium_current_m_gate"}, + {"h1", "dimensionless", "sodium_current_h_gate"}, + {"h2", "dimensionless", "sodium_current_h_gate"}, + {"f_L", "dimensionless", "L_type_Ca_channel_f_gate"}, + {"d_L", "dimensionless", "L_type_Ca_channel_d_gate"}, + {"f_T", "dimensionless", "T_type_Ca_channel_f_gate"}, + {"d_T", "dimensionless", "T_type_Ca_channel_d_gate"}, + {"r", "dimensionless", "four_AP_sensitive_currents_r_gate"}, + {"q", "dimensionless", "four_AP_sensitive_currents_q_gate"}, + {"P_i", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_i_gate"}, + {"P_af", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_af_gate"}, + {"P_as", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"xs", "dimensionless", "slow_delayed_rectifying_potassium_current_xs_gate"}, + {"y", "dimensionless", "hyperpolarisation_activated_current_y_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"dCell", "dimensionless", "membrane", CONSTANT}, - {"Version", "dimensionless", "membrane", CONSTANT}, - {"FCellConstant", "dimensionless", "membrane", CONSTANT}, - {"CmCentre", "microF", "membrane", CONSTANT}, - {"CmPeriphery", "microF", "membrane", CONSTANT}, - {"R", "millijoule_per_mole_kelvin", "membrane", CONSTANT}, - {"T", "kelvin", "membrane", CONSTANT}, - {"F", "coulomb_per_mole", "membrane", CONSTANT}, - {"g_b_Na_Centre_Published", "microS", "sodium_background_current", CONSTANT}, - {"g_b_Na_Periphery_Published", "microS", "sodium_background_current", CONSTANT}, - {"g_b_Na_Centre_1DCapable", "microS", "sodium_background_current", CONSTANT}, - {"g_b_Na_Periphery_1DCapable", "microS", "sodium_background_current", CONSTANT}, - {"g_b_Na_Centre_0DCapable", "microS", "sodium_background_current", CONSTANT}, - {"g_b_Na_Periphery_0DCapable", "microS", "sodium_background_current", CONSTANT}, - {"g_b_K_Centre_Published", "microS", "potassium_background_current", CONSTANT}, - {"g_b_K_Periphery_Published", "microS", "potassium_background_current", CONSTANT}, - {"g_b_K_Centre_1DCapable", "microS", "potassium_background_current", CONSTANT}, - {"g_b_K_Periphery_1DCapable", "microS", "potassium_background_current", CONSTANT}, - {"g_b_K_Centre_0DCapable", "microS", "potassium_background_current", CONSTANT}, - {"g_b_K_Periphery_0DCapable", "microS", "potassium_background_current", CONSTANT}, - {"g_b_Ca_Centre_Published", "microS", "calcium_background_current", CONSTANT}, - {"g_b_Ca_Periphery_Published", "microS", "calcium_background_current", CONSTANT}, - {"g_b_Ca_Centre_1DCapable", "microS", "calcium_background_current", CONSTANT}, - {"g_b_Ca_Periphery_1DCapable", "microS", "calcium_background_current", CONSTANT}, - {"g_b_Ca_Centre_0DCapable", "microS", "calcium_background_current", CONSTANT}, - {"g_b_Ca_Periphery_0DCapable", "microS", "calcium_background_current", CONSTANT}, - {"k_NaCa_Centre_Published", "nanoA", "sodium_calcium_exchanger", CONSTANT}, - {"k_NaCa_Periphery_Published", "nanoA", "sodium_calcium_exchanger", CONSTANT}, - {"k_NaCa_Centre_1DCapable", "nanoA", "sodium_calcium_exchanger", CONSTANT}, - {"k_NaCa_Periphery_1DCapable", "nanoA", "sodium_calcium_exchanger", CONSTANT}, - {"k_NaCa_Centre_0DCapable", "nanoA", "sodium_calcium_exchanger", CONSTANT}, - {"k_NaCa_Periphery_0DCapable", "nanoA", "sodium_calcium_exchanger", CONSTANT}, - {"Na_i", "millimolar", "ionic_concentrations", CONSTANT}, - {"gamma_NaCa", "dimensionless", "sodium_calcium_exchanger", CONSTANT}, - {"Ca_o", "millimolar", "ionic_concentrations", CONSTANT}, - {"Na_o", "millimolar", "ionic_concentrations", CONSTANT}, - {"Ca_i", "millimolar", "ionic_concentrations", CONSTANT}, - {"d_NaCa", "dimensionless", "sodium_calcium_exchanger", CONSTANT}, - {"i_p_max_Centre_Published", "nanoA", "sodium_potassium_pump", CONSTANT}, - {"i_p_max_Periphery_Published", "nanoA", "sodium_potassium_pump", CONSTANT}, - {"i_p_max_Centre_1DCapable", "nanoA", "sodium_potassium_pump", CONSTANT}, - {"i_p_max_Periphery_1DCapable", "nanoA", "sodium_potassium_pump", CONSTANT}, - {"i_p_max_Centre_0DCapable", "nanoA", "sodium_potassium_pump", CONSTANT}, - {"i_p_max_Periphery_0DCapable", "nanoA", "sodium_potassium_pump", CONSTANT}, - {"K_o", "millimolar", "ionic_concentrations", CONSTANT}, - {"K_m_K", "millimolar", "sodium_potassium_pump", CONSTANT}, - {"K_m_Na", "millimolar", "sodium_potassium_pump", CONSTANT}, - {"i_Ca_p_max_Centre_Published", "nanoA", "persistent_calcium_current", CONSTANT}, - {"i_Ca_p_max_Periphery_Published", "nanoA", "persistent_calcium_current", CONSTANT}, - {"i_Ca_p_max_Centre_1DCapable", "nanoA", "persistent_calcium_current", CONSTANT}, - {"i_Ca_p_max_Periphery_1DCapable", "nanoA", "persistent_calcium_current", CONSTANT}, - {"i_Ca_p_max_Centre_0DCapable", "nanoA", "persistent_calcium_current", CONSTANT}, - {"i_Ca_p_max_Periphery_0DCapable", "nanoA", "persistent_calcium_current", CONSTANT}, - {"K_i", "millimolar", "ionic_concentrations", CONSTANT}, - {"g_Na_Centre_Published", "microlitre_per_second", "sodium_current", CONSTANT}, - {"g_Na_Periphery_Published", "microlitre_per_second", "sodium_current", CONSTANT}, - {"g_Na_Centre_1DCapable", "microlitre_per_second", "sodium_current", CONSTANT}, - {"g_Na_Periphery_1DCapable", "microlitre_per_second", "sodium_current", CONSTANT}, - {"g_Na_Centre_0DCapable", "microlitre_per_second", "sodium_current", CONSTANT}, - {"g_Na_Periphery_0DCapable", "microlitre_per_second", "sodium_current", CONSTANT}, - {"g_Ca_L_Centre_Published", "microS", "L_type_Ca_channel", CONSTANT}, - {"g_Ca_L_Periphery_Published", "microS", "L_type_Ca_channel", CONSTANT}, - {"g_Ca_L_Centre_1DCapable", "microS", "L_type_Ca_channel", CONSTANT}, - {"g_Ca_L_Periphery_1DCapable", "microS", "L_type_Ca_channel", CONSTANT}, - {"g_Ca_L_Centre_0DCapable", "microS", "L_type_Ca_channel", CONSTANT}, - {"g_Ca_L_Periphery_0DCapable", "microS", "L_type_Ca_channel", CONSTANT}, - {"E_Ca_L", "millivolt", "L_type_Ca_channel", CONSTANT}, - {"g_Ca_T_Centre_Published", "microS", "T_type_Ca_channel", CONSTANT}, - {"g_Ca_T_Periphery_Published", "microS", "T_type_Ca_channel", CONSTANT}, - {"g_Ca_T_Centre_1DCapable", "microS", "T_type_Ca_channel", CONSTANT}, - {"g_Ca_T_Periphery_1DCapable", "microS", "T_type_Ca_channel", CONSTANT}, - {"g_Ca_T_Centre_0DCapable", "microS", "T_type_Ca_channel", CONSTANT}, - {"g_Ca_T_Periphery_0DCapable", "microS", "T_type_Ca_channel", CONSTANT}, - {"E_Ca_T", "millivolt", "T_type_Ca_channel", CONSTANT}, - {"g_to_Centre_Published", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_to_Periphery_Published", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_to_Centre_1DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_to_Periphery_1DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_to_Centre_0DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_to_Periphery_0DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_sus_Centre_Published", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_sus_Periphery_Published", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_sus_Centre_1DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_sus_Periphery_1DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_sus_Centre_0DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_sus_Periphery_0DCapable", "microS", "four_AP_sensitive_currents", CONSTANT}, - {"g_K_r_Centre_Published", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, - {"g_K_r_Periphery_Published", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, - {"g_K_r_Centre_1DCapable", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, - {"g_K_r_Periphery_1DCapable", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, - {"g_K_r_Centre_0DCapable", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, - {"g_K_r_Periphery_0DCapable", "microS", "rapid_delayed_rectifying_potassium_current", CONSTANT}, - {"g_K_s_Centre_Published", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, - {"g_K_s_Periphery_Published", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, - {"g_K_s_Centre_1DCapable", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, - {"g_K_s_Periphery_1DCapable", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, - {"g_K_s_Centre_0DCapable", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, - {"g_K_s_Periphery_0DCapable", "microS", "slow_delayed_rectifying_potassium_current", CONSTANT}, - {"g_f_Na_Centre_Published", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_Na_Periphery_Published", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_Na_Centre_1DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_Na_Periphery_1DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_Na_Centre_0DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_Na_Periphery_0DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_K_Centre_Published", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_K_Periphery_Published", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_K_Centre_1DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_K_Periphery_1DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_K_Centre_0DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT}, - {"g_f_K_Periphery_0DCapable", "microS", "hyperpolarisation_activated_current", CONSTANT} + {"dCell", "dimensionless", "membrane"}, + {"Version", "dimensionless", "membrane"}, + {"FCellConstant", "dimensionless", "membrane"}, + {"CmCentre", "microF", "membrane"}, + {"CmPeriphery", "microF", "membrane"}, + {"R", "millijoule_per_mole_kelvin", "membrane"}, + {"T", "kelvin", "membrane"}, + {"F", "coulomb_per_mole", "membrane"}, + {"g_b_Na_Centre_Published", "microS", "sodium_background_current"}, + {"g_b_Na_Periphery_Published", "microS", "sodium_background_current"}, + {"g_b_Na_Centre_1DCapable", "microS", "sodium_background_current"}, + {"g_b_Na_Periphery_1DCapable", "microS", "sodium_background_current"}, + {"g_b_Na_Centre_0DCapable", "microS", "sodium_background_current"}, + {"g_b_Na_Periphery_0DCapable", "microS", "sodium_background_current"}, + {"g_b_K_Centre_Published", "microS", "potassium_background_current"}, + {"g_b_K_Periphery_Published", "microS", "potassium_background_current"}, + {"g_b_K_Centre_1DCapable", "microS", "potassium_background_current"}, + {"g_b_K_Periphery_1DCapable", "microS", "potassium_background_current"}, + {"g_b_K_Centre_0DCapable", "microS", "potassium_background_current"}, + {"g_b_K_Periphery_0DCapable", "microS", "potassium_background_current"}, + {"g_b_Ca_Centre_Published", "microS", "calcium_background_current"}, + {"g_b_Ca_Periphery_Published", "microS", "calcium_background_current"}, + {"g_b_Ca_Centre_1DCapable", "microS", "calcium_background_current"}, + {"g_b_Ca_Periphery_1DCapable", "microS", "calcium_background_current"}, + {"g_b_Ca_Centre_0DCapable", "microS", "calcium_background_current"}, + {"g_b_Ca_Periphery_0DCapable", "microS", "calcium_background_current"}, + {"k_NaCa_Centre_Published", "nanoA", "sodium_calcium_exchanger"}, + {"k_NaCa_Periphery_Published", "nanoA", "sodium_calcium_exchanger"}, + {"k_NaCa_Centre_1DCapable", "nanoA", "sodium_calcium_exchanger"}, + {"k_NaCa_Periphery_1DCapable", "nanoA", "sodium_calcium_exchanger"}, + {"k_NaCa_Centre_0DCapable", "nanoA", "sodium_calcium_exchanger"}, + {"k_NaCa_Periphery_0DCapable", "nanoA", "sodium_calcium_exchanger"}, + {"Na_i", "millimolar", "ionic_concentrations"}, + {"gamma_NaCa", "dimensionless", "sodium_calcium_exchanger"}, + {"Ca_o", "millimolar", "ionic_concentrations"}, + {"Na_o", "millimolar", "ionic_concentrations"}, + {"Ca_i", "millimolar", "ionic_concentrations"}, + {"d_NaCa", "dimensionless", "sodium_calcium_exchanger"}, + {"i_p_max_Centre_Published", "nanoA", "sodium_potassium_pump"}, + {"i_p_max_Periphery_Published", "nanoA", "sodium_potassium_pump"}, + {"i_p_max_Centre_1DCapable", "nanoA", "sodium_potassium_pump"}, + {"i_p_max_Periphery_1DCapable", "nanoA", "sodium_potassium_pump"}, + {"i_p_max_Centre_0DCapable", "nanoA", "sodium_potassium_pump"}, + {"i_p_max_Periphery_0DCapable", "nanoA", "sodium_potassium_pump"}, + {"K_o", "millimolar", "ionic_concentrations"}, + {"K_m_K", "millimolar", "sodium_potassium_pump"}, + {"K_m_Na", "millimolar", "sodium_potassium_pump"}, + {"i_Ca_p_max_Centre_Published", "nanoA", "persistent_calcium_current"}, + {"i_Ca_p_max_Periphery_Published", "nanoA", "persistent_calcium_current"}, + {"i_Ca_p_max_Centre_1DCapable", "nanoA", "persistent_calcium_current"}, + {"i_Ca_p_max_Periphery_1DCapable", "nanoA", "persistent_calcium_current"}, + {"i_Ca_p_max_Centre_0DCapable", "nanoA", "persistent_calcium_current"}, + {"i_Ca_p_max_Periphery_0DCapable", "nanoA", "persistent_calcium_current"}, + {"K_i", "millimolar", "ionic_concentrations"}, + {"g_Na_Centre_Published", "microlitre_per_second", "sodium_current"}, + {"g_Na_Periphery_Published", "microlitre_per_second", "sodium_current"}, + {"g_Na_Centre_1DCapable", "microlitre_per_second", "sodium_current"}, + {"g_Na_Periphery_1DCapable", "microlitre_per_second", "sodium_current"}, + {"g_Na_Centre_0DCapable", "microlitre_per_second", "sodium_current"}, + {"g_Na_Periphery_0DCapable", "microlitre_per_second", "sodium_current"}, + {"g_Ca_L_Centre_Published", "microS", "L_type_Ca_channel"}, + {"g_Ca_L_Periphery_Published", "microS", "L_type_Ca_channel"}, + {"g_Ca_L_Centre_1DCapable", "microS", "L_type_Ca_channel"}, + {"g_Ca_L_Periphery_1DCapable", "microS", "L_type_Ca_channel"}, + {"g_Ca_L_Centre_0DCapable", "microS", "L_type_Ca_channel"}, + {"g_Ca_L_Periphery_0DCapable", "microS", "L_type_Ca_channel"}, + {"E_Ca_L", "millivolt", "L_type_Ca_channel"}, + {"g_Ca_T_Centre_Published", "microS", "T_type_Ca_channel"}, + {"g_Ca_T_Periphery_Published", "microS", "T_type_Ca_channel"}, + {"g_Ca_T_Centre_1DCapable", "microS", "T_type_Ca_channel"}, + {"g_Ca_T_Periphery_1DCapable", "microS", "T_type_Ca_channel"}, + {"g_Ca_T_Centre_0DCapable", "microS", "T_type_Ca_channel"}, + {"g_Ca_T_Periphery_0DCapable", "microS", "T_type_Ca_channel"}, + {"E_Ca_T", "millivolt", "T_type_Ca_channel"}, + {"g_to_Centre_Published", "microS", "four_AP_sensitive_currents"}, + {"g_to_Periphery_Published", "microS", "four_AP_sensitive_currents"}, + {"g_to_Centre_1DCapable", "microS", "four_AP_sensitive_currents"}, + {"g_to_Periphery_1DCapable", "microS", "four_AP_sensitive_currents"}, + {"g_to_Centre_0DCapable", "microS", "four_AP_sensitive_currents"}, + {"g_to_Periphery_0DCapable", "microS", "four_AP_sensitive_currents"}, + {"g_sus_Centre_Published", "microS", "four_AP_sensitive_currents"}, + {"g_sus_Periphery_Published", "microS", "four_AP_sensitive_currents"}, + {"g_sus_Centre_1DCapable", "microS", "four_AP_sensitive_currents"}, + {"g_sus_Periphery_1DCapable", "microS", "four_AP_sensitive_currents"}, + {"g_sus_Centre_0DCapable", "microS", "four_AP_sensitive_currents"}, + {"g_sus_Periphery_0DCapable", "microS", "four_AP_sensitive_currents"}, + {"g_K_r_Centre_Published", "microS", "rapid_delayed_rectifying_potassium_current"}, + {"g_K_r_Periphery_Published", "microS", "rapid_delayed_rectifying_potassium_current"}, + {"g_K_r_Centre_1DCapable", "microS", "rapid_delayed_rectifying_potassium_current"}, + {"g_K_r_Periphery_1DCapable", "microS", "rapid_delayed_rectifying_potassium_current"}, + {"g_K_r_Centre_0DCapable", "microS", "rapid_delayed_rectifying_potassium_current"}, + {"g_K_r_Periphery_0DCapable", "microS", "rapid_delayed_rectifying_potassium_current"}, + {"g_K_s_Centre_Published", "microS", "slow_delayed_rectifying_potassium_current"}, + {"g_K_s_Periphery_Published", "microS", "slow_delayed_rectifying_potassium_current"}, + {"g_K_s_Centre_1DCapable", "microS", "slow_delayed_rectifying_potassium_current"}, + {"g_K_s_Periphery_1DCapable", "microS", "slow_delayed_rectifying_potassium_current"}, + {"g_K_s_Centre_0DCapable", "microS", "slow_delayed_rectifying_potassium_current"}, + {"g_K_s_Periphery_0DCapable", "microS", "slow_delayed_rectifying_potassium_current"}, + {"g_f_Na_Centre_Published", "microS", "hyperpolarisation_activated_current"}, + {"g_f_Na_Periphery_Published", "microS", "hyperpolarisation_activated_current"}, + {"g_f_Na_Centre_1DCapable", "microS", "hyperpolarisation_activated_current"}, + {"g_f_Na_Periphery_1DCapable", "microS", "hyperpolarisation_activated_current"}, + {"g_f_Na_Centre_0DCapable", "microS", "hyperpolarisation_activated_current"}, + {"g_f_Na_Periphery_0DCapable", "microS", "hyperpolarisation_activated_current"}, + {"g_f_K_Centre_Published", "microS", "hyperpolarisation_activated_current"}, + {"g_f_K_Periphery_Published", "microS", "hyperpolarisation_activated_current"}, + {"g_f_K_Centre_1DCapable", "microS", "hyperpolarisation_activated_current"}, + {"g_f_K_Periphery_1DCapable", "microS", "hyperpolarisation_activated_current"}, + {"g_f_K_Centre_0DCapable", "microS", "hyperpolarisation_activated_current"}, + {"g_f_K_Periphery_0DCapable", "microS", "hyperpolarisation_activated_current"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"FCell", "dimensionless", "membrane", COMPUTED_CONSTANT}, - {"Cm", "microF", "membrane", COMPUTED_CONSTANT}, - {"i_Ca_p", "nanoA", "persistent_calcium_current", COMPUTED_CONSTANT}, - {"g_b_Na", "microS", "sodium_background_current", COMPUTED_CONSTANT}, - {"E_Na", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, - {"g_b_K", "microS", "potassium_background_current", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, - {"g_b_Ca", "microS", "calcium_background_current", COMPUTED_CONSTANT}, - {"E_Ca", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, - {"k_NaCa", "nanoA", "sodium_calcium_exchanger", COMPUTED_CONSTANT}, - {"i_p_max", "nanoA", "sodium_potassium_pump", COMPUTED_CONSTANT}, - {"i_Ca_p_max", "nanoA", "persistent_calcium_current", COMPUTED_CONSTANT}, - {"E_K_s", "millivolt", "reversal_and_equilibrium_potentials", COMPUTED_CONSTANT}, - {"g_Na", "microlitre_per_second", "sodium_current", COMPUTED_CONSTANT}, - {"g_Ca_L", "microS", "L_type_Ca_channel", COMPUTED_CONSTANT}, - {"g_Ca_T", "microS", "T_type_Ca_channel", COMPUTED_CONSTANT}, - {"g_to", "microS", "four_AP_sensitive_currents", COMPUTED_CONSTANT}, - {"g_sus", "microS", "four_AP_sensitive_currents", COMPUTED_CONSTANT}, - {"g_K_r", "microS", "rapid_delayed_rectifying_potassium_current", COMPUTED_CONSTANT}, - {"tau_P_i", "second", "rapid_delayed_rectifying_potassium_current_P_i_gate", COMPUTED_CONSTANT}, - {"g_K_s", "microS", "slow_delayed_rectifying_potassium_current", COMPUTED_CONSTANT}, - {"g_f_Na", "microS", "hyperpolarisation_activated_current", COMPUTED_CONSTANT}, - {"g_f_K", "microS", "hyperpolarisation_activated_current", COMPUTED_CONSTANT} + {"FCell", "dimensionless", "membrane"}, + {"Cm", "microF", "membrane"}, + {"i_Ca_p", "nanoA", "persistent_calcium_current"}, + {"g_b_Na", "microS", "sodium_background_current"}, + {"E_Na", "millivolt", "reversal_and_equilibrium_potentials"}, + {"g_b_K", "microS", "potassium_background_current"}, + {"E_K", "millivolt", "reversal_and_equilibrium_potentials"}, + {"g_b_Ca", "microS", "calcium_background_current"}, + {"E_Ca", "millivolt", "reversal_and_equilibrium_potentials"}, + {"k_NaCa", "nanoA", "sodium_calcium_exchanger"}, + {"i_p_max", "nanoA", "sodium_potassium_pump"}, + {"i_Ca_p_max", "nanoA", "persistent_calcium_current"}, + {"E_K_s", "millivolt", "reversal_and_equilibrium_potentials"}, + {"g_Na", "microlitre_per_second", "sodium_current"}, + {"g_Ca_L", "microS", "L_type_Ca_channel"}, + {"g_Ca_T", "microS", "T_type_Ca_channel"}, + {"g_to", "microS", "four_AP_sensitive_currents"}, + {"g_sus", "microS", "four_AP_sensitive_currents"}, + {"g_K_r", "microS", "rapid_delayed_rectifying_potassium_current"}, + {"tau_P_i", "second", "rapid_delayed_rectifying_potassium_current_P_i_gate"}, + {"g_K_s", "microS", "slow_delayed_rectifying_potassium_current"}, + {"g_f_Na", "microS", "hyperpolarisation_activated_current"}, + {"g_f_K", "microS", "hyperpolarisation_activated_current"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Na", "nanoA", "sodium_current", ALGEBRAIC}, - {"i_p", "nanoA", "sodium_potassium_pump", ALGEBRAIC}, - {"i_NaCa", "nanoA", "sodium_calcium_exchanger", ALGEBRAIC}, - {"i_b_K", "nanoA", "potassium_background_current", ALGEBRAIC}, - {"i_b_Ca", "nanoA", "calcium_background_current", ALGEBRAIC}, - {"i_b_Na", "nanoA", "sodium_background_current", ALGEBRAIC}, - {"i_f_K", "nanoA", "hyperpolarisation_activated_current", ALGEBRAIC}, - {"i_f_Na", "nanoA", "hyperpolarisation_activated_current", ALGEBRAIC}, - {"i_K_s", "nanoA", "slow_delayed_rectifying_potassium_current", ALGEBRAIC}, - {"i_K_r", "nanoA", "rapid_delayed_rectifying_potassium_current", ALGEBRAIC}, - {"i_sus", "nanoA", "four_AP_sensitive_currents", ALGEBRAIC}, - {"i_to", "nanoA", "four_AP_sensitive_currents", ALGEBRAIC}, - {"i_Ca_T", "nanoA", "T_type_Ca_channel", ALGEBRAIC}, - {"i_Ca_L", "nanoA", "L_type_Ca_channel", ALGEBRAIC}, - {"h", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, - {"m_infinity", "dimensionless", "sodium_current_m_gate", ALGEBRAIC}, - {"tau_m", "second", "sodium_current_m_gate", ALGEBRAIC}, - {"F_Na", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, - {"h1_infinity", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, - {"tau_h1", "second", "sodium_current_h_gate", ALGEBRAIC}, - {"h2_infinity", "dimensionless", "sodium_current_h_gate", ALGEBRAIC}, - {"tau_h2", "second", "sodium_current_h_gate", ALGEBRAIC}, - {"d_L_infinity", "dimensionless", "L_type_Ca_channel_d_gate", ALGEBRAIC}, - {"tau_d_L", "second", "L_type_Ca_channel_d_gate", ALGEBRAIC}, - {"alpha_d_L", "per_second", "L_type_Ca_channel_d_gate", ALGEBRAIC}, - {"beta_d_L", "per_second", "L_type_Ca_channel_d_gate", ALGEBRAIC}, - {"f_L_infinity", "dimensionless", "L_type_Ca_channel_f_gate", ALGEBRAIC}, - {"tau_f_L", "second", "L_type_Ca_channel_f_gate", ALGEBRAIC}, - {"alpha_f_L", "per_second", "L_type_Ca_channel_f_gate", ALGEBRAIC}, - {"beta_f_L", "per_second", "L_type_Ca_channel_f_gate", ALGEBRAIC}, - {"d_T_infinity", "dimensionless", "T_type_Ca_channel_d_gate", ALGEBRAIC}, - {"tau_d_T", "second", "T_type_Ca_channel_d_gate", ALGEBRAIC}, - {"alpha_d_T", "per_second", "T_type_Ca_channel_d_gate", ALGEBRAIC}, - {"beta_d_T", "per_second", "T_type_Ca_channel_d_gate", ALGEBRAIC}, - {"f_T_infinity", "dimensionless", "T_type_Ca_channel_f_gate", ALGEBRAIC}, - {"tau_f_T", "second", "T_type_Ca_channel_f_gate", ALGEBRAIC}, - {"alpha_f_T", "per_second", "T_type_Ca_channel_f_gate", ALGEBRAIC}, - {"beta_f_T", "per_second", "T_type_Ca_channel_f_gate", ALGEBRAIC}, - {"q_infinity", "dimensionless", "four_AP_sensitive_currents_q_gate", ALGEBRAIC}, - {"tau_q", "second", "four_AP_sensitive_currents_q_gate", ALGEBRAIC}, - {"r_infinity", "dimensionless", "four_AP_sensitive_currents_r_gate", ALGEBRAIC}, - {"tau_r", "second", "four_AP_sensitive_currents_r_gate", ALGEBRAIC}, - {"P_a", "dimensionless", "rapid_delayed_rectifying_potassium_current", ALGEBRAIC}, - {"P_af_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_af_gate", ALGEBRAIC}, - {"tau_P_af", "second", "rapid_delayed_rectifying_potassium_current_P_af_gate", ALGEBRAIC}, - {"P_as_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_as_gate", ALGEBRAIC}, - {"tau_P_as", "second", "rapid_delayed_rectifying_potassium_current_P_as_gate", ALGEBRAIC}, - {"P_i_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_i_gate", ALGEBRAIC}, - {"alpha_xs", "per_second", "slow_delayed_rectifying_potassium_current_xs_gate", ALGEBRAIC}, - {"beta_xs", "per_second", "slow_delayed_rectifying_potassium_current_xs_gate", ALGEBRAIC}, - {"alpha_y", "per_second", "hyperpolarisation_activated_current_y_gate", ALGEBRAIC}, - {"beta_y", "per_second", "hyperpolarisation_activated_current_y_gate", ALGEBRAIC} + {"i_Na", "nanoA", "sodium_current"}, + {"i_p", "nanoA", "sodium_potassium_pump"}, + {"i_NaCa", "nanoA", "sodium_calcium_exchanger"}, + {"i_b_K", "nanoA", "potassium_background_current"}, + {"i_b_Ca", "nanoA", "calcium_background_current"}, + {"i_b_Na", "nanoA", "sodium_background_current"}, + {"i_f_K", "nanoA", "hyperpolarisation_activated_current"}, + {"i_f_Na", "nanoA", "hyperpolarisation_activated_current"}, + {"i_K_s", "nanoA", "slow_delayed_rectifying_potassium_current"}, + {"i_K_r", "nanoA", "rapid_delayed_rectifying_potassium_current"}, + {"i_sus", "nanoA", "four_AP_sensitive_currents"}, + {"i_to", "nanoA", "four_AP_sensitive_currents"}, + {"i_Ca_T", "nanoA", "T_type_Ca_channel"}, + {"i_Ca_L", "nanoA", "L_type_Ca_channel"}, + {"h", "dimensionless", "sodium_current_h_gate"}, + {"m_infinity", "dimensionless", "sodium_current_m_gate"}, + {"tau_m", "second", "sodium_current_m_gate"}, + {"F_Na", "dimensionless", "sodium_current_h_gate"}, + {"h1_infinity", "dimensionless", "sodium_current_h_gate"}, + {"tau_h1", "second", "sodium_current_h_gate"}, + {"h2_infinity", "dimensionless", "sodium_current_h_gate"}, + {"tau_h2", "second", "sodium_current_h_gate"}, + {"d_L_infinity", "dimensionless", "L_type_Ca_channel_d_gate"}, + {"tau_d_L", "second", "L_type_Ca_channel_d_gate"}, + {"alpha_d_L", "per_second", "L_type_Ca_channel_d_gate"}, + {"beta_d_L", "per_second", "L_type_Ca_channel_d_gate"}, + {"f_L_infinity", "dimensionless", "L_type_Ca_channel_f_gate"}, + {"tau_f_L", "second", "L_type_Ca_channel_f_gate"}, + {"alpha_f_L", "per_second", "L_type_Ca_channel_f_gate"}, + {"beta_f_L", "per_second", "L_type_Ca_channel_f_gate"}, + {"d_T_infinity", "dimensionless", "T_type_Ca_channel_d_gate"}, + {"tau_d_T", "second", "T_type_Ca_channel_d_gate"}, + {"alpha_d_T", "per_second", "T_type_Ca_channel_d_gate"}, + {"beta_d_T", "per_second", "T_type_Ca_channel_d_gate"}, + {"f_T_infinity", "dimensionless", "T_type_Ca_channel_f_gate"}, + {"tau_f_T", "second", "T_type_Ca_channel_f_gate"}, + {"alpha_f_T", "per_second", "T_type_Ca_channel_f_gate"}, + {"beta_f_T", "per_second", "T_type_Ca_channel_f_gate"}, + {"q_infinity", "dimensionless", "four_AP_sensitive_currents_q_gate"}, + {"tau_q", "second", "four_AP_sensitive_currents_q_gate"}, + {"r_infinity", "dimensionless", "four_AP_sensitive_currents_r_gate"}, + {"tau_r", "second", "four_AP_sensitive_currents_r_gate"}, + {"P_a", "dimensionless", "rapid_delayed_rectifying_potassium_current"}, + {"P_af_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_af_gate"}, + {"tau_P_af", "second", "rapid_delayed_rectifying_potassium_current_P_af_gate"}, + {"P_as_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"tau_P_as", "second", "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"P_i_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_i_gate"}, + {"alpha_xs", "per_second", "slow_delayed_rectifying_potassium_current_xs_gate"}, + {"beta_xs", "per_second", "slow_delayed_rectifying_potassium_current_xs_gate"}, + {"alpha_y", "per_second", "hyperpolarisation_activated_current_y_gate"}, + {"beta_y", "per_second", "hyperpolarisation_activated_current_y_gate"} }; double * createStatesArray() diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 5838d8bc8..4edb4f720 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[31]; char units[27]; char component[53]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 01844df2c..a10fd42ef 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -12,226 +12,217 @@ COMPUTED_CONSTANT_COUNT = 23 ALGEBRAIC_COUNT = 52 +VOI_INFO = {"name": "time", "units": "second", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "time", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "sodium_current_m_gate", "type": VariableType.STATE}, - {"name": "h1", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.STATE}, - {"name": "h2", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.STATE}, - {"name": "f_L", "units": "dimensionless", "component": "L_type_Ca_channel_f_gate", "type": VariableType.STATE}, - {"name": "d_L", "units": "dimensionless", "component": "L_type_Ca_channel_d_gate", "type": VariableType.STATE}, - {"name": "f_T", "units": "dimensionless", "component": "T_type_Ca_channel_f_gate", "type": VariableType.STATE}, - {"name": "d_T", "units": "dimensionless", "component": "T_type_Ca_channel_d_gate", "type": VariableType.STATE}, - {"name": "r", "units": "dimensionless", "component": "four_AP_sensitive_currents_r_gate", "type": VariableType.STATE}, - {"name": "q", "units": "dimensionless", "component": "four_AP_sensitive_currents_q_gate", "type": VariableType.STATE}, - {"name": "P_i", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate", "type": VariableType.STATE}, - {"name": "P_af", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate", "type": VariableType.STATE}, - {"name": "P_as", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate", "type": VariableType.STATE}, - {"name": "xs", "units": "dimensionless", "component": "slow_delayed_rectifying_potassium_current_xs_gate", "type": VariableType.STATE}, - {"name": "y", "units": "dimensionless", "component": "hyperpolarisation_activated_current_y_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "m", "units": "dimensionless", "component": "sodium_current_m_gate"}, + {"name": "h1", "units": "dimensionless", "component": "sodium_current_h_gate"}, + {"name": "h2", "units": "dimensionless", "component": "sodium_current_h_gate"}, + {"name": "f_L", "units": "dimensionless", "component": "L_type_Ca_channel_f_gate"}, + {"name": "d_L", "units": "dimensionless", "component": "L_type_Ca_channel_d_gate"}, + {"name": "f_T", "units": "dimensionless", "component": "T_type_Ca_channel_f_gate"}, + {"name": "d_T", "units": "dimensionless", "component": "T_type_Ca_channel_d_gate"}, + {"name": "r", "units": "dimensionless", "component": "four_AP_sensitive_currents_r_gate"}, + {"name": "q", "units": "dimensionless", "component": "four_AP_sensitive_currents_q_gate"}, + {"name": "P_i", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate"}, + {"name": "P_af", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate"}, + {"name": "P_as", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"name": "xs", "units": "dimensionless", "component": "slow_delayed_rectifying_potassium_current_xs_gate"}, + {"name": "y", "units": "dimensionless", "component": "hyperpolarisation_activated_current_y_gate"} CONSTANT_INFO = [ - {"name": "dCell", "units": "dimensionless", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "Version", "units": "dimensionless", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "FCellConstant", "units": "dimensionless", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "CmCentre", "units": "microF", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "CmPeriphery", "units": "microF", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "R", "units": "millijoule_per_mole_kelvin", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "T", "units": "kelvin", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "F", "units": "coulomb_per_mole", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_b_Na_Centre_Published", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_Na_Periphery_Published", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_Na_Centre_1DCapable", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_Na_Periphery_1DCapable", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_Na_Centre_0DCapable", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_Na_Periphery_0DCapable", "units": "microS", "component": "sodium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_K_Centre_Published", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_K_Periphery_Published", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_K_Centre_1DCapable", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_K_Periphery_1DCapable", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_K_Centre_0DCapable", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_K_Periphery_0DCapable", "units": "microS", "component": "potassium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_Ca_Centre_Published", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_Ca_Periphery_Published", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_Ca_Centre_1DCapable", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_Ca_Periphery_1DCapable", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_Ca_Centre_0DCapable", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, - {"name": "g_b_Ca_Periphery_0DCapable", "units": "microS", "component": "calcium_background_current", "type": VariableType.CONSTANT}, - {"name": "k_NaCa_Centre_Published", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, - {"name": "k_NaCa_Periphery_Published", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, - {"name": "k_NaCa_Centre_1DCapable", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, - {"name": "k_NaCa_Periphery_1DCapable", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, - {"name": "k_NaCa_Centre_0DCapable", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, - {"name": "k_NaCa_Periphery_0DCapable", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, - {"name": "Na_i", "units": "millimolar", "component": "ionic_concentrations", "type": VariableType.CONSTANT}, - {"name": "gamma_NaCa", "units": "dimensionless", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, - {"name": "Ca_o", "units": "millimolar", "component": "ionic_concentrations", "type": VariableType.CONSTANT}, - {"name": "Na_o", "units": "millimolar", "component": "ionic_concentrations", "type": VariableType.CONSTANT}, - {"name": "Ca_i", "units": "millimolar", "component": "ionic_concentrations", "type": VariableType.CONSTANT}, - {"name": "d_NaCa", "units": "dimensionless", "component": "sodium_calcium_exchanger", "type": VariableType.CONSTANT}, - {"name": "i_p_max_Centre_Published", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, - {"name": "i_p_max_Periphery_Published", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, - {"name": "i_p_max_Centre_1DCapable", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, - {"name": "i_p_max_Periphery_1DCapable", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, - {"name": "i_p_max_Centre_0DCapable", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, - {"name": "i_p_max_Periphery_0DCapable", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, - {"name": "K_o", "units": "millimolar", "component": "ionic_concentrations", "type": VariableType.CONSTANT}, - {"name": "K_m_K", "units": "millimolar", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, - {"name": "K_m_Na", "units": "millimolar", "component": "sodium_potassium_pump", "type": VariableType.CONSTANT}, - {"name": "i_Ca_p_max_Centre_Published", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.CONSTANT}, - {"name": "i_Ca_p_max_Periphery_Published", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.CONSTANT}, - {"name": "i_Ca_p_max_Centre_1DCapable", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.CONSTANT}, - {"name": "i_Ca_p_max_Periphery_1DCapable", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.CONSTANT}, - {"name": "i_Ca_p_max_Centre_0DCapable", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.CONSTANT}, - {"name": "i_Ca_p_max_Periphery_0DCapable", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.CONSTANT}, - {"name": "K_i", "units": "millimolar", "component": "ionic_concentrations", "type": VariableType.CONSTANT}, - {"name": "g_Na_Centre_Published", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, - {"name": "g_Na_Periphery_Published", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, - {"name": "g_Na_Centre_1DCapable", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, - {"name": "g_Na_Periphery_1DCapable", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, - {"name": "g_Na_Centre_0DCapable", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, - {"name": "g_Na_Periphery_0DCapable", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.CONSTANT}, - {"name": "g_Ca_L_Centre_Published", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_Ca_L_Periphery_Published", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_Ca_L_Centre_1DCapable", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_Ca_L_Periphery_1DCapable", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_Ca_L_Centre_0DCapable", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_Ca_L_Periphery_0DCapable", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "E_Ca_L", "units": "millivolt", "component": "L_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_Ca_T_Centre_Published", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_Ca_T_Periphery_Published", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_Ca_T_Centre_1DCapable", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_Ca_T_Periphery_1DCapable", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_Ca_T_Centre_0DCapable", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_Ca_T_Periphery_0DCapable", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "E_Ca_T", "units": "millivolt", "component": "T_type_Ca_channel", "type": VariableType.CONSTANT}, - {"name": "g_to_Centre_Published", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_to_Periphery_Published", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_to_Centre_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_to_Periphery_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_to_Centre_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_to_Periphery_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_sus_Centre_Published", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_sus_Periphery_Published", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_sus_Centre_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_sus_Periphery_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_sus_Centre_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_sus_Periphery_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.CONSTANT}, - {"name": "g_K_r_Centre_Published", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_K_r_Periphery_Published", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_K_r_Centre_1DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_K_r_Periphery_1DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_K_r_Centre_0DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_K_r_Periphery_0DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_K_s_Centre_Published", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_K_s_Periphery_Published", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_K_s_Centre_1DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_K_s_Periphery_1DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_K_s_Centre_0DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_K_s_Periphery_0DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.CONSTANT}, - {"name": "g_f_Na_Centre_Published", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_Na_Periphery_Published", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_Na_Centre_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_Na_Periphery_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_Na_Centre_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_Na_Periphery_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_K_Centre_Published", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_K_Periphery_Published", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_K_Centre_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_K_Periphery_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_K_Centre_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT}, - {"name": "g_f_K_Periphery_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.CONSTANT} + {"name": "dCell", "units": "dimensionless", "component": "membrane"}, + {"name": "Version", "units": "dimensionless", "component": "membrane"}, + {"name": "FCellConstant", "units": "dimensionless", "component": "membrane"}, + {"name": "CmCentre", "units": "microF", "component": "membrane"}, + {"name": "CmPeriphery", "units": "microF", "component": "membrane"}, + {"name": "R", "units": "millijoule_per_mole_kelvin", "component": "membrane"}, + {"name": "T", "units": "kelvin", "component": "membrane"}, + {"name": "F", "units": "coulomb_per_mole", "component": "membrane"}, + {"name": "g_b_Na_Centre_Published", "units": "microS", "component": "sodium_background_current"}, + {"name": "g_b_Na_Periphery_Published", "units": "microS", "component": "sodium_background_current"}, + {"name": "g_b_Na_Centre_1DCapable", "units": "microS", "component": "sodium_background_current"}, + {"name": "g_b_Na_Periphery_1DCapable", "units": "microS", "component": "sodium_background_current"}, + {"name": "g_b_Na_Centre_0DCapable", "units": "microS", "component": "sodium_background_current"}, + {"name": "g_b_Na_Periphery_0DCapable", "units": "microS", "component": "sodium_background_current"}, + {"name": "g_b_K_Centre_Published", "units": "microS", "component": "potassium_background_current"}, + {"name": "g_b_K_Periphery_Published", "units": "microS", "component": "potassium_background_current"}, + {"name": "g_b_K_Centre_1DCapable", "units": "microS", "component": "potassium_background_current"}, + {"name": "g_b_K_Periphery_1DCapable", "units": "microS", "component": "potassium_background_current"}, + {"name": "g_b_K_Centre_0DCapable", "units": "microS", "component": "potassium_background_current"}, + {"name": "g_b_K_Periphery_0DCapable", "units": "microS", "component": "potassium_background_current"}, + {"name": "g_b_Ca_Centre_Published", "units": "microS", "component": "calcium_background_current"}, + {"name": "g_b_Ca_Periphery_Published", "units": "microS", "component": "calcium_background_current"}, + {"name": "g_b_Ca_Centre_1DCapable", "units": "microS", "component": "calcium_background_current"}, + {"name": "g_b_Ca_Periphery_1DCapable", "units": "microS", "component": "calcium_background_current"}, + {"name": "g_b_Ca_Centre_0DCapable", "units": "microS", "component": "calcium_background_current"}, + {"name": "g_b_Ca_Periphery_0DCapable", "units": "microS", "component": "calcium_background_current"}, + {"name": "k_NaCa_Centre_Published", "units": "nanoA", "component": "sodium_calcium_exchanger"}, + {"name": "k_NaCa_Periphery_Published", "units": "nanoA", "component": "sodium_calcium_exchanger"}, + {"name": "k_NaCa_Centre_1DCapable", "units": "nanoA", "component": "sodium_calcium_exchanger"}, + {"name": "k_NaCa_Periphery_1DCapable", "units": "nanoA", "component": "sodium_calcium_exchanger"}, + {"name": "k_NaCa_Centre_0DCapable", "units": "nanoA", "component": "sodium_calcium_exchanger"}, + {"name": "k_NaCa_Periphery_0DCapable", "units": "nanoA", "component": "sodium_calcium_exchanger"}, + {"name": "Na_i", "units": "millimolar", "component": "ionic_concentrations"}, + {"name": "gamma_NaCa", "units": "dimensionless", "component": "sodium_calcium_exchanger"}, + {"name": "Ca_o", "units": "millimolar", "component": "ionic_concentrations"}, + {"name": "Na_o", "units": "millimolar", "component": "ionic_concentrations"}, + {"name": "Ca_i", "units": "millimolar", "component": "ionic_concentrations"}, + {"name": "d_NaCa", "units": "dimensionless", "component": "sodium_calcium_exchanger"}, + {"name": "i_p_max_Centre_Published", "units": "nanoA", "component": "sodium_potassium_pump"}, + {"name": "i_p_max_Periphery_Published", "units": "nanoA", "component": "sodium_potassium_pump"}, + {"name": "i_p_max_Centre_1DCapable", "units": "nanoA", "component": "sodium_potassium_pump"}, + {"name": "i_p_max_Periphery_1DCapable", "units": "nanoA", "component": "sodium_potassium_pump"}, + {"name": "i_p_max_Centre_0DCapable", "units": "nanoA", "component": "sodium_potassium_pump"}, + {"name": "i_p_max_Periphery_0DCapable", "units": "nanoA", "component": "sodium_potassium_pump"}, + {"name": "K_o", "units": "millimolar", "component": "ionic_concentrations"}, + {"name": "K_m_K", "units": "millimolar", "component": "sodium_potassium_pump"}, + {"name": "K_m_Na", "units": "millimolar", "component": "sodium_potassium_pump"}, + {"name": "i_Ca_p_max_Centre_Published", "units": "nanoA", "component": "persistent_calcium_current"}, + {"name": "i_Ca_p_max_Periphery_Published", "units": "nanoA", "component": "persistent_calcium_current"}, + {"name": "i_Ca_p_max_Centre_1DCapable", "units": "nanoA", "component": "persistent_calcium_current"}, + {"name": "i_Ca_p_max_Periphery_1DCapable", "units": "nanoA", "component": "persistent_calcium_current"}, + {"name": "i_Ca_p_max_Centre_0DCapable", "units": "nanoA", "component": "persistent_calcium_current"}, + {"name": "i_Ca_p_max_Periphery_0DCapable", "units": "nanoA", "component": "persistent_calcium_current"}, + {"name": "K_i", "units": "millimolar", "component": "ionic_concentrations"}, + {"name": "g_Na_Centre_Published", "units": "microlitre_per_second", "component": "sodium_current"}, + {"name": "g_Na_Periphery_Published", "units": "microlitre_per_second", "component": "sodium_current"}, + {"name": "g_Na_Centre_1DCapable", "units": "microlitre_per_second", "component": "sodium_current"}, + {"name": "g_Na_Periphery_1DCapable", "units": "microlitre_per_second", "component": "sodium_current"}, + {"name": "g_Na_Centre_0DCapable", "units": "microlitre_per_second", "component": "sodium_current"}, + {"name": "g_Na_Periphery_0DCapable", "units": "microlitre_per_second", "component": "sodium_current"}, + {"name": "g_Ca_L_Centre_Published", "units": "microS", "component": "L_type_Ca_channel"}, + {"name": "g_Ca_L_Periphery_Published", "units": "microS", "component": "L_type_Ca_channel"}, + {"name": "g_Ca_L_Centre_1DCapable", "units": "microS", "component": "L_type_Ca_channel"}, + {"name": "g_Ca_L_Periphery_1DCapable", "units": "microS", "component": "L_type_Ca_channel"}, + {"name": "g_Ca_L_Centre_0DCapable", "units": "microS", "component": "L_type_Ca_channel"}, + {"name": "g_Ca_L_Periphery_0DCapable", "units": "microS", "component": "L_type_Ca_channel"}, + {"name": "E_Ca_L", "units": "millivolt", "component": "L_type_Ca_channel"}, + {"name": "g_Ca_T_Centre_Published", "units": "microS", "component": "T_type_Ca_channel"}, + {"name": "g_Ca_T_Periphery_Published", "units": "microS", "component": "T_type_Ca_channel"}, + {"name": "g_Ca_T_Centre_1DCapable", "units": "microS", "component": "T_type_Ca_channel"}, + {"name": "g_Ca_T_Periphery_1DCapable", "units": "microS", "component": "T_type_Ca_channel"}, + {"name": "g_Ca_T_Centre_0DCapable", "units": "microS", "component": "T_type_Ca_channel"}, + {"name": "g_Ca_T_Periphery_0DCapable", "units": "microS", "component": "T_type_Ca_channel"}, + {"name": "E_Ca_T", "units": "millivolt", "component": "T_type_Ca_channel"}, + {"name": "g_to_Centre_Published", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_to_Periphery_Published", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_to_Centre_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_to_Periphery_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_to_Centre_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_to_Periphery_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_sus_Centre_Published", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_sus_Periphery_Published", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_sus_Centre_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_sus_Periphery_1DCapable", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_sus_Centre_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_sus_Periphery_0DCapable", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_K_r_Centre_Published", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current"}, + {"name": "g_K_r_Periphery_Published", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current"}, + {"name": "g_K_r_Centre_1DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current"}, + {"name": "g_K_r_Periphery_1DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current"}, + {"name": "g_K_r_Centre_0DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current"}, + {"name": "g_K_r_Periphery_0DCapable", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current"}, + {"name": "g_K_s_Centre_Published", "units": "microS", "component": "slow_delayed_rectifying_potassium_current"}, + {"name": "g_K_s_Periphery_Published", "units": "microS", "component": "slow_delayed_rectifying_potassium_current"}, + {"name": "g_K_s_Centre_1DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current"}, + {"name": "g_K_s_Periphery_1DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current"}, + {"name": "g_K_s_Centre_0DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current"}, + {"name": "g_K_s_Periphery_0DCapable", "units": "microS", "component": "slow_delayed_rectifying_potassium_current"}, + {"name": "g_f_Na_Centre_Published", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_Na_Periphery_Published", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_Na_Centre_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_Na_Periphery_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_Na_Centre_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_Na_Periphery_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_K_Centre_Published", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_K_Periphery_Published", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_K_Centre_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_K_Periphery_1DCapable", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_K_Centre_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_K_Periphery_0DCapable", "units": "microS", "component": "hyperpolarisation_activated_current"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "FCell", "units": "dimensionless", "component": "membrane", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "Cm", "units": "microF", "component": "membrane", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "i_Ca_p", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_b_Na", "units": "microS", "component": "sodium_background_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_b_K", "units": "microS", "component": "potassium_background_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_b_Ca", "units": "microS", "component": "calcium_background_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_Ca", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "k_NaCa", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "i_p_max", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "i_Ca_p_max", "units": "nanoA", "component": "persistent_calcium_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K_s", "units": "millivolt", "component": "reversal_and_equilibrium_potentials", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_Na", "units": "microlitre_per_second", "component": "sodium_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_Ca_L", "units": "microS", "component": "L_type_Ca_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_Ca_T", "units": "microS", "component": "T_type_Ca_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_to", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_sus", "units": "microS", "component": "four_AP_sensitive_currents", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K_r", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "tau_P_i", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_K_s", "units": "microS", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_f_Na", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "g_f_K", "units": "microS", "component": "hyperpolarisation_activated_current", "type": VariableType.COMPUTED_CONSTANT} + {"name": "FCell", "units": "dimensionless", "component": "membrane"}, + {"name": "Cm", "units": "microF", "component": "membrane"}, + {"name": "i_Ca_p", "units": "nanoA", "component": "persistent_calcium_current"}, + {"name": "g_b_Na", "units": "microS", "component": "sodium_background_current"}, + {"name": "E_Na", "units": "millivolt", "component": "reversal_and_equilibrium_potentials"}, + {"name": "g_b_K", "units": "microS", "component": "potassium_background_current"}, + {"name": "E_K", "units": "millivolt", "component": "reversal_and_equilibrium_potentials"}, + {"name": "g_b_Ca", "units": "microS", "component": "calcium_background_current"}, + {"name": "E_Ca", "units": "millivolt", "component": "reversal_and_equilibrium_potentials"}, + {"name": "k_NaCa", "units": "nanoA", "component": "sodium_calcium_exchanger"}, + {"name": "i_p_max", "units": "nanoA", "component": "sodium_potassium_pump"}, + {"name": "i_Ca_p_max", "units": "nanoA", "component": "persistent_calcium_current"}, + {"name": "E_K_s", "units": "millivolt", "component": "reversal_and_equilibrium_potentials"}, + {"name": "g_Na", "units": "microlitre_per_second", "component": "sodium_current"}, + {"name": "g_Ca_L", "units": "microS", "component": "L_type_Ca_channel"}, + {"name": "g_Ca_T", "units": "microS", "component": "T_type_Ca_channel"}, + {"name": "g_to", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_sus", "units": "microS", "component": "four_AP_sensitive_currents"}, + {"name": "g_K_r", "units": "microS", "component": "rapid_delayed_rectifying_potassium_current"}, + {"name": "tau_P_i", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate"}, + {"name": "g_K_s", "units": "microS", "component": "slow_delayed_rectifying_potassium_current"}, + {"name": "g_f_Na", "units": "microS", "component": "hyperpolarisation_activated_current"}, + {"name": "g_f_K", "units": "microS", "component": "hyperpolarisation_activated_current"} ] ALGEBRAIC_INFO = [ - {"name": "i_Na", "units": "nanoA", "component": "sodium_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_p", "units": "nanoA", "component": "sodium_potassium_pump", "type": VariableType.ALGEBRAIC}, - {"name": "i_NaCa", "units": "nanoA", "component": "sodium_calcium_exchanger", "type": VariableType.ALGEBRAIC}, - {"name": "i_b_K", "units": "nanoA", "component": "potassium_background_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_b_Ca", "units": "nanoA", "component": "calcium_background_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_b_Na", "units": "nanoA", "component": "sodium_background_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_f_K", "units": "nanoA", "component": "hyperpolarisation_activated_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_f_Na", "units": "nanoA", "component": "hyperpolarisation_activated_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K_s", "units": "nanoA", "component": "slow_delayed_rectifying_potassium_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K_r", "units": "nanoA", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_sus", "units": "nanoA", "component": "four_AP_sensitive_currents", "type": VariableType.ALGEBRAIC}, - {"name": "i_to", "units": "nanoA", "component": "four_AP_sensitive_currents", "type": VariableType.ALGEBRAIC}, - {"name": "i_Ca_T", "units": "nanoA", "component": "T_type_Ca_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Ca_L", "units": "nanoA", "component": "L_type_Ca_channel", "type": VariableType.ALGEBRAIC}, - {"name": "h", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "m_infinity", "units": "dimensionless", "component": "sodium_current_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_m", "units": "second", "component": "sodium_current_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "F_Na", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "h1_infinity", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_h1", "units": "second", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "h2_infinity", "units": "dimensionless", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_h2", "units": "second", "component": "sodium_current_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "d_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_d_L", "units": "second", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_d_L", "units": "per_second", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_d_L", "units": "per_second", "component": "L_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "f_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_f_L", "units": "second", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_f_L", "units": "per_second", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_f_L", "units": "per_second", "component": "L_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "d_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_d_T", "units": "second", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_d_T", "units": "per_second", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_d_T", "units": "per_second", "component": "T_type_Ca_channel_d_gate", "type": VariableType.ALGEBRAIC}, - {"name": "f_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_f_T", "units": "second", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_f_T", "units": "per_second", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_f_T", "units": "per_second", "component": "T_type_Ca_channel_f_gate", "type": VariableType.ALGEBRAIC}, - {"name": "q_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_q_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_q", "units": "second", "component": "four_AP_sensitive_currents_q_gate", "type": VariableType.ALGEBRAIC}, - {"name": "r_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_r_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_r", "units": "second", "component": "four_AP_sensitive_currents_r_gate", "type": VariableType.ALGEBRAIC}, - {"name": "P_a", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current", "type": VariableType.ALGEBRAIC}, - {"name": "P_af_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_P_af", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate", "type": VariableType.ALGEBRAIC}, - {"name": "P_as_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate", "type": VariableType.ALGEBRAIC}, - {"name": "tau_P_as", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate", "type": VariableType.ALGEBRAIC}, - {"name": "P_i_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_xs", "units": "per_second", "component": "slow_delayed_rectifying_potassium_current_xs_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_xs", "units": "per_second", "component": "slow_delayed_rectifying_potassium_current_xs_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_y", "units": "per_second", "component": "hyperpolarisation_activated_current_y_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_y", "units": "per_second", "component": "hyperpolarisation_activated_current_y_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_Na", "units": "nanoA", "component": "sodium_current"}, + {"name": "i_p", "units": "nanoA", "component": "sodium_potassium_pump"}, + {"name": "i_NaCa", "units": "nanoA", "component": "sodium_calcium_exchanger"}, + {"name": "i_b_K", "units": "nanoA", "component": "potassium_background_current"}, + {"name": "i_b_Ca", "units": "nanoA", "component": "calcium_background_current"}, + {"name": "i_b_Na", "units": "nanoA", "component": "sodium_background_current"}, + {"name": "i_f_K", "units": "nanoA", "component": "hyperpolarisation_activated_current"}, + {"name": "i_f_Na", "units": "nanoA", "component": "hyperpolarisation_activated_current"}, + {"name": "i_K_s", "units": "nanoA", "component": "slow_delayed_rectifying_potassium_current"}, + {"name": "i_K_r", "units": "nanoA", "component": "rapid_delayed_rectifying_potassium_current"}, + {"name": "i_sus", "units": "nanoA", "component": "four_AP_sensitive_currents"}, + {"name": "i_to", "units": "nanoA", "component": "four_AP_sensitive_currents"}, + {"name": "i_Ca_T", "units": "nanoA", "component": "T_type_Ca_channel"}, + {"name": "i_Ca_L", "units": "nanoA", "component": "L_type_Ca_channel"}, + {"name": "h", "units": "dimensionless", "component": "sodium_current_h_gate"}, + {"name": "m_infinity", "units": "dimensionless", "component": "sodium_current_m_gate"}, + {"name": "tau_m", "units": "second", "component": "sodium_current_m_gate"}, + {"name": "F_Na", "units": "dimensionless", "component": "sodium_current_h_gate"}, + {"name": "h1_infinity", "units": "dimensionless", "component": "sodium_current_h_gate"}, + {"name": "tau_h1", "units": "second", "component": "sodium_current_h_gate"}, + {"name": "h2_infinity", "units": "dimensionless", "component": "sodium_current_h_gate"}, + {"name": "tau_h2", "units": "second", "component": "sodium_current_h_gate"}, + {"name": "d_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_d_gate"}, + {"name": "tau_d_L", "units": "second", "component": "L_type_Ca_channel_d_gate"}, + {"name": "alpha_d_L", "units": "per_second", "component": "L_type_Ca_channel_d_gate"}, + {"name": "beta_d_L", "units": "per_second", "component": "L_type_Ca_channel_d_gate"}, + {"name": "f_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_f_gate"}, + {"name": "tau_f_L", "units": "second", "component": "L_type_Ca_channel_f_gate"}, + {"name": "alpha_f_L", "units": "per_second", "component": "L_type_Ca_channel_f_gate"}, + {"name": "beta_f_L", "units": "per_second", "component": "L_type_Ca_channel_f_gate"}, + {"name": "d_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_d_gate"}, + {"name": "tau_d_T", "units": "second", "component": "T_type_Ca_channel_d_gate"}, + {"name": "alpha_d_T", "units": "per_second", "component": "T_type_Ca_channel_d_gate"}, + {"name": "beta_d_T", "units": "per_second", "component": "T_type_Ca_channel_d_gate"}, + {"name": "f_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_f_gate"}, + {"name": "tau_f_T", "units": "second", "component": "T_type_Ca_channel_f_gate"}, + {"name": "alpha_f_T", "units": "per_second", "component": "T_type_Ca_channel_f_gate"}, + {"name": "beta_f_T", "units": "per_second", "component": "T_type_Ca_channel_f_gate"}, + {"name": "q_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_q_gate"}, + {"name": "tau_q", "units": "second", "component": "four_AP_sensitive_currents_q_gate"}, + {"name": "r_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_r_gate"}, + {"name": "tau_r", "units": "second", "component": "four_AP_sensitive_currents_r_gate"}, + {"name": "P_a", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current"}, + {"name": "P_af_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate"}, + {"name": "tau_P_af", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate"}, + {"name": "P_as_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"name": "tau_P_as", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"name": "P_i_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate"}, + {"name": "alpha_xs", "units": "per_second", "component": "slow_delayed_rectifying_potassium_current_xs_gate"}, + {"name": "beta_xs", "units": "per_second", "component": "slow_delayed_rectifying_potassium_current_xs_gate"}, + {"name": "alpha_y", "units": "per_second", "component": "hyperpolarisation_activated_current_y_gate"}, + {"name": "beta_y", "units": "per_second", "component": "hyperpolarisation_activated_current_y_gate"} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index f917c7664..8bb552378 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -14,43 +14,43 @@ const size_t COMPUTED_CONSTANT_COUNT = 3; const size_t ALGEBRAIC_COUNT = 9; const size_t EXTERNAL_COUNT = 1; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane", STATE}, - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"m", "dimensionless", "sodium_channel_m_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", CONSTANT}, - {"E_R", "millivolt", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; const VariableInfo EXTERNAL_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", EXTERNAL} + {"i_Stim", "microA_per_cm2", "membrane"} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index 5fb0b0dbc..87c9d97a5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -13,20 +13,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[8]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 069d0600d..1b9d75ed2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -13,52 +13,42 @@ ALGEBRAIC_COUNT = 9 EXTERNAL_COUNT = 1 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - EXTERNAL = 5 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] ALGEBRAIC_INFO = [ - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] EXTERNAL_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL} + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index e031f85b4..77ac9b4be 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -13,40 +13,40 @@ const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 3; const size_t ALGEBRAIC_COUNT = 10; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane", STATE}, - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"m", "dimensionless", "sodium_channel_m_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", CONSTANT}, - {"E_R", "millivolt", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 6d9bf826c..b47898024 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -14,43 +14,43 @@ const size_t COMPUTED_CONSTANT_COUNT = 2; const size_t ALGEBRAIC_COUNT = 10; const size_t EXTERNAL_COUNT = 1; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane", STATE}, - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"m", "dimensionless", "sodium_channel_m_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", CONSTANT}, - {"E_R", "millivolt", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; const VariableInfo EXTERNAL_INFO[] = { - {"E_L", "millivolt", "leakage_current", EXTERNAL} + {"E_L", "millivolt", "leakage_current"} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index 5fb0b0dbc..87c9d97a5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -13,20 +13,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[8]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index b8319e0fd..45f4360d8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -13,52 +13,42 @@ ALGEBRAIC_COUNT = 10 EXTERNAL_COUNT = 1 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - EXTERNAL = 5 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] ALGEBRAIC_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] EXTERNAL_INFO = [ - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.EXTERNAL} + {"name": "E_L", "units": "millivolt", "component": "leakage_current"} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 5637ee56e..7de8288be 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -14,43 +14,43 @@ const size_t COMPUTED_CONSTANT_COUNT = 3; const size_t ALGEBRAIC_COUNT = 10; const size_t EXTERNAL_COUNT = 1; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane", STATE}, - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"m", "dimensionless", "sodium_channel_m_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"E_R", "millivolt", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; const VariableInfo EXTERNAL_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", EXTERNAL} + {"Cm", "microF_per_cm2", "membrane"} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index 5fb0b0dbc..87c9d97a5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -13,20 +13,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[8]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index bb2ac5e62..96c8a1f6e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -13,52 +13,42 @@ ALGEBRAIC_COUNT = 10 EXTERNAL_COUNT = 1 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - EXTERNAL = 5 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] ALGEBRAIC_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] EXTERNAL_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 4fd81f7a0..d15936a8a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -13,40 +13,40 @@ const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 3; const size_t ALGEBRAIC_COUNT = 10; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane", STATE}, - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"m", "dimensionless", "sodium_channel_m_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", CONSTANT}, - {"E_R", "millivolt", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index 7a76b71af..d64d07bb6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[8]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index a58ab9416..9293f1936 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -12,48 +12,39 @@ COMPUTED_CONSTANT_COUNT = 3 ALGEBRAIC_COUNT = 10 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] ALGEBRAIC_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index b51c60bfd..070a92f7b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -14,43 +14,43 @@ const size_t COMPUTED_CONSTANT_COUNT = 3; const size_t ALGEBRAIC_COUNT = 8; const size_t EXTERNAL_COUNT = 2; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane", STATE}, - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"m", "dimensionless", "sodium_channel_m_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", CONSTANT}, - {"E_R", "millivolt", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"} }; const VariableInfo EXTERNAL_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", EXTERNAL}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", EXTERNAL} + {"i_Stim", "microA_per_cm2", "membrane"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index 5fb0b0dbc..87c9d97a5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -13,20 +13,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[8]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 715e2a036..a03e31643 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -13,52 +13,42 @@ ALGEBRAIC_COUNT = 8 EXTERNAL_COUNT = 2 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - EXTERNAL = 5 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] ALGEBRAIC_INFO = [ - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] EXTERNAL_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.EXTERNAL} + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index c27fbd144..d34a01efc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -14,43 +14,43 @@ const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 12; const size_t EXTERNAL_COUNT = 2; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane", STATE}, - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"m", "dimensionless", "sodium_channel_m_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} + {"Cm", "microF_per_cm2", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"E_L", "millivolt", "leakage_current", ALGEBRAIC}, - {"E_Na", "millivolt", "sodium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; const VariableInfo EXTERNAL_INFO[] = { - {"E_R", "millivolt", "membrane", EXTERNAL}, - {"E_K", "millivolt", "potassium_channel", EXTERNAL} + {"E_R", "millivolt", "membrane"}, + {"E_K", "millivolt", "potassium_channel"} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index 5fb0b0dbc..87c9d97a5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -13,20 +13,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[8]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 4bd387526..e655d50b5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -13,52 +13,42 @@ ALGEBRAIC_COUNT = 12 EXTERNAL_COUNT = 2 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - EXTERNAL = 5 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} ] COMPUTED_CONSTANT_INFO = [ ] ALGEBRAIC_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] EXTERNAL_INFO = [ - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.EXTERNAL} + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 125ae8722..c93e668a0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -14,43 +14,43 @@ const size_t COMPUTED_CONSTANT_COUNT = 3; const size_t ALGEBRAIC_COUNT = 10; const size_t EXTERNAL_COUNT = 2; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane", STATE}, - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"m", "dimensionless", "sodium_channel_m_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"E_R", "millivolt", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; const VariableInfo EXTERNAL_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", EXTERNAL}, - {"g_Na", "milliS_per_cm2", "sodium_channel", EXTERNAL} + {"Cm", "microF_per_cm2", "membrane"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index 5fb0b0dbc..87c9d97a5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -13,20 +13,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[8]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 78a627ae1..bdb693b0d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -13,52 +13,42 @@ ALGEBRAIC_COUNT = 10 EXTERNAL_COUNT = 2 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - EXTERNAL = 5 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] ALGEBRAIC_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] EXTERNAL_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.EXTERNAL}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.EXTERNAL} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index f8caa7651..f7bfa5c34 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -14,43 +14,43 @@ const size_t COMPUTED_CONSTANT_COUNT = 3; const size_t ALGEBRAIC_COUNT = 10; const size_t EXTERNAL_COUNT = 2; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", CONSTANT}, - {"E_R", "millivolt", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; const VariableInfo EXTERNAL_INFO[] = { - {"V", "millivolt", "membrane", EXTERNAL}, - {"m", "dimensionless", "sodium_channel_m_gate", EXTERNAL} + {"V", "millivolt", "membrane"}, + {"m", "dimensionless", "sodium_channel_m_gate"} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index 5fb0b0dbc..87c9d97a5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -13,20 +13,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[8]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 6d926cf22..ef8be939e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -13,52 +13,42 @@ ALGEBRAIC_COUNT = 10 EXTERNAL_COUNT = 2 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - EXTERNAL = 5 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] ALGEBRAIC_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] EXTERNAL_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.EXTERNAL} + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index c3b86c0a3..6682384a4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -14,43 +14,43 @@ const size_t COMPUTED_CONSTANT_COUNT = 3; const size_t ALGEBRAIC_COUNT = 8; const size_t EXTERNAL_COUNT = 3; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"m", "dimensionless", "sodium_channel_m_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", CONSTANT}, - {"E_R", "millivolt", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; const VariableInfo EXTERNAL_INFO[] = { - {"V", "millivolt", "membrane", EXTERNAL}, - {"i_Na", "microA_per_cm2", "sodium_channel", EXTERNAL}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", EXTERNAL} + {"V", "millivolt", "membrane"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index 5fb0b0dbc..87c9d97a5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -13,20 +13,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[8]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 8ec0625ce..7a5b0bf19 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -13,52 +13,42 @@ ALGEBRAIC_COUNT = 8 EXTERNAL_COUNT = 3 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - EXTERNAL = 5 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] ALGEBRAIC_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] EXTERNAL_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.EXTERNAL}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.EXTERNAL}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.EXTERNAL} + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index 7a76b71af..d64d07bb6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[8]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 6f1ab2d37..161468ab2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -12,48 +12,39 @@ COMPUTED_CONSTANT_COUNT = 3 ALGEBRAIC_COUNT = 10 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] ALGEBRAIC_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 2492a86c0..69ac3783d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -14,43 +14,43 @@ const size_t COMPUTED_CONSTANT_COUNT = 3; const size_t ALGEBRAIC_COUNT = 10; const size_t EXTERNAL_COUNT = 1; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane", STATE}, - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"V", "millivolt", "membrane"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", CONSTANT}, - {"E_R", "millivolt", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"g_Na", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"g_K", "milliS_per_cm2", "potassium_channel", CONSTANT} + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_L", "millivolt", "leakage_current", COMPUTED_CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", COMPUTED_CONSTANT}, - {"E_K", "millivolt", "potassium_channel", COMPUTED_CONSTANT} + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"E_K", "millivolt", "potassium_channel"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Stim", "microA_per_cm2", "membrane", ALGEBRAIC}, - {"i_L", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; const VariableInfo EXTERNAL_INFO[] = { - {"m", "dimensionless", "sodium_channel_m_gate", EXTERNAL} + {"m", "dimensionless", "sodium_channel_m_gate"} }; double * createStatesArray() diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index 5fb0b0dbc..87c9d97a5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -13,20 +13,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[8]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 40c52077b..1574fc8fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -13,52 +13,42 @@ ALGEBRAIC_COUNT = 10 EXTERNAL_COUNT = 1 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - EXTERNAL = 5 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "E_R", "units": "millivolt", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.CONSTANT} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel", "type": VariableType.COMPUTED_CONSTANT} + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] ALGEBRAIC_INFO = [ - {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane", "type": VariableType.ALGEBRAIC}, - {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] EXTERNAL_INFO = [ - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.EXTERNAL} + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"} ] diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 796622169..42e464392 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -13,39 +13,39 @@ const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 12; -const VariableInfo VOI_INFO = {"time", "millisecond", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { - {"V", "millivolt", "membrane", STATE}, - {"m", "dimensionless", "sodium_channel_m_gate", STATE}, - {"h", "dimensionless", "sodium_channel_h_gate", STATE}, - {"n", "dimensionless", "potassium_channel_n_gate", STATE} + {"V", "millivolt", "membrane"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { - {"Cm", "microF_per_cm2", "membrane", CONSTANT}, - {"g_L", "milliS_per_cm2", "leakage_current", CONSTANT}, - {"E_L", "millivolt", "leakage_current", CONSTANT}, - {"g_Na_max", "milliS_per_cm2", "sodium_channel", CONSTANT}, - {"E_Na", "millivolt", "sodium_channel", CONSTANT} + {"Cm", "microF_per_cm2", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"E_L", "millivolt", "leakage_current"}, + {"g_Na_max", "milliS_per_cm2", "sodium_channel"}, + {"E_Na", "millivolt", "sodium_channel"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Na", "microA_per_cm2", "sodium_channel", ALGEBRAIC}, - {"i_Leak", "microA_per_cm2", "leakage_current", ALGEBRAIC}, - {"i_K", "microA_per_cm2", "potassium_channel", ALGEBRAIC}, - {"g_Na", "milliS_per_cm2", "sodium_channel", ALGEBRAIC}, - {"alpha_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"beta_m", "per_millisecond", "sodium_channel_m_gate", ALGEBRAIC}, - {"alpha_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"beta_h", "per_millisecond", "sodium_channel_h_gate", ALGEBRAIC}, - {"g_K1", "milliS_per_cm2", "potassium_channel", ALGEBRAIC}, - {"g_K2", "milliS_per_cm2", "potassium_channel", ALGEBRAIC}, - {"alpha_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC}, - {"beta_n", "per_millisecond", "potassium_channel_n_gate", ALGEBRAIC} + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"i_Leak", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"g_K1", "milliS_per_cm2", "potassium_channel"}, + {"g_K2", "milliS_per_cm2", "potassium_channel"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; double * createStatesArray() diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index 76e98a854..a4c01ffa0 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[9]; char units[16]; char component[25]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 7a19fb3e3..0b75dd777 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -12,47 +12,38 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 12 +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane", "type": VariableType.STATE}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate", "type": VariableType.STATE}, - {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate", "type": VariableType.STATE}, - {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate", "type": VariableType.STATE} +STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} CONSTANT_INFO = [ - {"name": "Cm", "units": "microF_per_cm2", "component": "membrane", "type": VariableType.CONSTANT}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "E_L", "units": "millivolt", "component": "leakage_current", "type": VariableType.CONSTANT}, - {"name": "g_Na_max", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.CONSTANT}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel", "type": VariableType.CONSTANT} + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "g_Na_max", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"} ] COMPUTED_CONSTANT_INFO = [ ] ALGEBRAIC_INFO = [ - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "i_Leak", "units": "microA_per_cm2", "component": "leakage_current", "type": VariableType.ALGEBRAIC}, - {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate", "type": VariableType.ALGEBRAIC}, - {"name": "g_K1", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "g_K2", "units": "milliS_per_cm2", "component": "potassium_channel", "type": VariableType.ALGEBRAIC}, - {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC}, - {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate", "type": VariableType.ALGEBRAIC} + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "i_Leak", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "g_K1", "units": "milliS_per_cm2", "component": "potassium_channel"}, + {"name": "g_K2", "units": "milliS_per_cm2", "component": "potassium_channel"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 1aee953d6..abf35649d 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -13,17 +13,17 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_ode", STATE} + {"x", "dimensionless", "my_ode"} }; const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"a", "per_s", "my_ode", COMPUTED_CONSTANT} + {"a", "per_s", "my_ode"} }; const VariableInfo ALGEBRAIC_INFO[] = { diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index 35acb1470..8d446982d 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index a0eefbb10..81b6db4c1 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -12,25 +12,16 @@ COMPUTED_CONSTANT_COUNT = 1 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode"} CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ - {"name": "a", "units": "per_s", "component": "my_ode", "type": VariableType.COMPUTED_CONSTANT} + {"name": "a", "units": "per_s", "component": "my_ode"} ] ALGEBRAIC_INFO = [ diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 5917645d3..e6eecbfdc 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -13,17 +13,17 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_component", STATE} + {"x", "dimensionless", "my_component"} }; const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"a", "per_s", "my_component", COMPUTED_CONSTANT} + {"a", "per_s", "my_component"} }; const VariableInfo ALGEBRAIC_INFO[] = { diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index ec1099767..1c36d8d5f 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[13]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 694094710..6f9c31e1e 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -12,25 +12,16 @@ COMPUTED_CONSTANT_COUNT = 1 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} CONSTANT_INFO = [ ] COMPUTED_CONSTANT_INFO = [ - {"name": "a", "units": "per_s", "component": "my_component", "type": VariableType.COMPUTED_CONSTANT} + {"name": "a", "units": "per_s", "component": "my_component"} ] ALGEBRAIC_INFO = [ diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index 900882221..a0af88531 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -13,14 +13,14 @@ const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_ode", STATE} + {"x", "dimensionless", "my_ode"} }; const VariableInfo CONSTANT_INFO[] = { - {"a", "per_s", "my_ode", CONSTANT} + {"a", "per_s", "my_ode"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index 35acb1470..8d446982d 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 183abb260..0bf4f4f64 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -12,22 +12,13 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode"} CONSTANT_INFO = [ - {"name": "a", "units": "per_s", "component": "my_ode", "type": VariableType.CONSTANT} + {"name": "a", "units": "per_s", "component": "my_ode"} ] COMPUTED_CONSTANT_INFO = [ diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index c982a3aa0..043bda45b 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -13,14 +13,14 @@ const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_component", STATE} + {"x", "dimensionless", "my_component"} }; const VariableInfo CONSTANT_INFO[] = { - {"a", "per_s", "my_component", CONSTANT} + {"a", "per_s", "my_component"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index ec1099767..1c36d8d5f 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[13]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 7fe189c7a..ea5912c7d 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -12,22 +12,13 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} CONSTANT_INFO = [ - {"name": "a", "units": "per_s", "component": "my_component", "type": VariableType.CONSTANT} + {"name": "a", "units": "per_s", "component": "my_component"} ] COMPUTED_CONSTANT_INFO = [ diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index d1981b036..67645bc1c 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -13,10 +13,10 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_ode", STATE} + {"x", "dimensionless", "my_ode"} }; const VariableInfo CONSTANT_INFO[] = { diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index 35acb1470..8d446982d 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index 1b1b18f96..9147b5ae6 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -12,18 +12,9 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode"} CONSTANT_INFO = [ diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index e299805f4..074534564 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -13,10 +13,10 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_component", STATE} + {"x", "dimensionless", "my_component"} }; const VariableInfo CONSTANT_INFO[] = { diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index ec1099767..1c36d8d5f 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[13]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index 81899058c..e159a2b5c 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -12,18 +12,9 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} CONSTANT_INFO = [ diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index c43f947e7..861ca5c1a 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -13,15 +13,15 @@ const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_x_ode", STATE}, - {"y", "dimensionless", "my_y_ode", STATE} + {"x", "dimensionless", "my_x_ode"}, + {"y", "dimensionless", "my_y_ode"} }; const VariableInfo CONSTANT_INFO[] = { - {"epsilon", "dimensionless", "my_y_ode", CONSTANT} + {"epsilon", "dimensionless", "my_y_ode"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index 82e013544..6b58848d0 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[8]; char units[14]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 6edcb43f7..5daabe1bc 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -12,23 +12,14 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_x_ode", "type": VariableType.STATE}, - {"name": "y", "units": "dimensionless", "component": "my_y_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_x_ode"}, + {"name": "y", "units": "dimensionless", "component": "my_y_ode"} CONSTANT_INFO = [ - {"name": "epsilon", "units": "dimensionless", "component": "my_y_ode", "type": VariableType.CONSTANT} + {"name": "epsilon", "units": "dimensionless", "component": "my_y_ode"} ] COMPUTED_CONSTANT_INFO = [ diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 9e5d0e295..f4347cdb6 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -13,15 +13,15 @@ const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "my_component", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "my_component"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_component", STATE}, - {"y", "dimensionless", "my_component", STATE} + {"x", "dimensionless", "my_component"}, + {"y", "dimensionless", "my_component"} }; const VariableInfo CONSTANT_INFO[] = { - {"epsilon", "dimensionless", "my_component", CONSTANT} + {"epsilon", "dimensionless", "my_component"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index 021fc3521..e4d23b9b6 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[8]; char units[14]; char component[13]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index adbe50fe7..073d05fac 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -12,23 +12,14 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "my_component", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE}, - {"name": "y", "units": "dimensionless", "component": "my_component", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"}, + {"name": "y", "units": "dimensionless", "component": "my_component"} CONSTANT_INFO = [ - {"name": "epsilon", "units": "dimensionless", "component": "my_component", "type": VariableType.CONSTANT} + {"name": "epsilon", "units": "dimensionless", "component": "my_component"} ] COMPUTED_CONSTANT_INFO = [ diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 4caef9231..140486722 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -13,15 +13,15 @@ const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_first_ode", STATE}, - {"x", "dimensionless", "my_second_ode", STATE} + {"x", "dimensionless", "my_first_ode"}, + {"x", "dimensionless", "my_second_ode"} }; const VariableInfo CONSTANT_INFO[] = { - {"a", "per_s", "my_second_ode", CONSTANT} + {"a", "per_s", "my_second_ode"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index 41b1e7be5..5c800ad65 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[14]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index d23db4467..ebce3e2e6 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -12,23 +12,14 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_first_ode", "type": VariableType.STATE}, - {"name": "x", "units": "dimensionless", "component": "my_second_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_first_ode"}, + {"name": "x", "units": "dimensionless", "component": "my_second_ode"} CONSTANT_INFO = [ - {"name": "a", "units": "per_s", "component": "my_second_ode", "type": VariableType.CONSTANT} + {"name": "a", "units": "per_s", "component": "my_second_ode"} ] COMPUTED_CONSTANT_INFO = [ diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index ab500425b..a27eb2cf0 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -13,11 +13,11 @@ const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "environment", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_ode", STATE}, - {"y", "dimensionless", "my_ode", STATE} + {"x", "dimensionless", "my_ode"}, + {"y", "dimensionless", "my_ode"} }; const VariableInfo CONSTANT_INFO[] = { diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index 35acb1470..8d446982d 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[2]; char units[14]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index f7b81c3c3..9e678173d 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -12,19 +12,10 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "environment", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE}, - {"name": "y", "units": "dimensionless", "component": "my_ode", "type": VariableType.STATE} +STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode"}, + {"name": "y", "units": "dimensionless", "component": "my_ode"} CONSTANT_INFO = [ diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 01a0c5db8..1c4dbb976 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -13,25 +13,25 @@ const size_t CONSTANT_COUNT = 3; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 2; -const VariableInfo VOI_INFO = {"t", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "dimensionless", "main"}; const VariableInfo STATE_INFO[] = { - {"y1", "dimensionless", "main", STATE}, - {"y2", "dimensionless", "main", STATE} + {"y1", "dimensionless", "main"}, + {"y2", "dimensionless", "main"} }; const VariableInfo CONSTANT_INFO[] = { - {"k1", "dimensionless", "main", CONSTANT}, - {"k3", "dimensionless", "main", CONSTANT}, - {"k2", "dimensionless", "main", CONSTANT} + {"k1", "dimensionless", "main"}, + {"k3", "dimensionless", "main"}, + {"k2", "dimensionless", "main"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"y3", "dimensionless", "main", ALGEBRAIC}, - {"y2_scaled", "dimensionless", "main", ALGEBRAIC} + {"y3", "dimensionless", "main"}, + {"y2_scaled", "dimensionless", "main"} }; double * createStatesArray() diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index f41a8e9e9..03322f766 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[10]; char units[14]; char component[5]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 41f161a81..83ae00049 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -12,33 +12,24 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 2 +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "y1", "units": "dimensionless", "component": "main", "type": VariableType.STATE}, - {"name": "y2", "units": "dimensionless", "component": "main", "type": VariableType.STATE} +STATE_INFO = {"name": "y1", "units": "dimensionless", "component": "main"}, + {"name": "y2", "units": "dimensionless", "component": "main"} CONSTANT_INFO = [ - {"name": "k1", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, - {"name": "k3", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, - {"name": "k2", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT} + {"name": "k1", "units": "dimensionless", "component": "main"}, + {"name": "k3", "units": "dimensionless", "component": "main"}, + {"name": "k2", "units": "dimensionless", "component": "main"} ] COMPUTED_CONSTANT_INFO = [ ] ALGEBRAIC_INFO = [ - {"name": "y3", "units": "dimensionless", "component": "main", "type": VariableType.ALGEBRAIC}, - {"name": "y2_scaled", "units": "dimensionless", "component": "main", "type": VariableType.ALGEBRAIC} + {"name": "y3", "units": "dimensionless", "component": "main"}, + {"name": "y2_scaled", "units": "dimensionless", "component": "main"} ] diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index fef5b5c53..ead2f0880 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -13,25 +13,25 @@ const size_t CONSTANT_COUNT = 3; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 1; -const VariableInfo VOI_INFO = {"t", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "dimensionless", "main"}; const VariableInfo STATE_INFO[] = { - {"y1", "dimensionless", "main", STATE}, - {"y3", "dimensionless", "main", STATE}, - {"y2", "dimensionless", "main", STATE} + {"y1", "dimensionless", "main"}, + {"y3", "dimensionless", "main"}, + {"y2", "dimensionless", "main"} }; const VariableInfo CONSTANT_INFO[] = { - {"k1", "dimensionless", "main", CONSTANT}, - {"k3", "dimensionless", "main", CONSTANT}, - {"k2", "dimensionless", "main", CONSTANT} + {"k1", "dimensionless", "main"}, + {"k3", "dimensionless", "main"}, + {"k2", "dimensionless", "main"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"y2_scaled", "dimensionless", "main", ALGEBRAIC} + {"y2_scaled", "dimensionless", "main"} }; double * createStatesArray() diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index f41a8e9e9..03322f766 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[10]; char units[14]; char component[5]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 832cb289d..6fd0e88e1 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -12,33 +12,24 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 1 +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "y1", "units": "dimensionless", "component": "main", "type": VariableType.STATE}, - {"name": "y3", "units": "dimensionless", "component": "main", "type": VariableType.STATE}, - {"name": "y2", "units": "dimensionless", "component": "main", "type": VariableType.STATE} +STATE_INFO = {"name": "y1", "units": "dimensionless", "component": "main"}, + {"name": "y3", "units": "dimensionless", "component": "main"}, + {"name": "y2", "units": "dimensionless", "component": "main"} CONSTANT_INFO = [ - {"name": "k1", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, - {"name": "k3", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, - {"name": "k2", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT} + {"name": "k1", "units": "dimensionless", "component": "main"}, + {"name": "k3", "units": "dimensionless", "component": "main"}, + {"name": "k2", "units": "dimensionless", "component": "main"} ] COMPUTED_CONSTANT_INFO = [ ] ALGEBRAIC_INFO = [ - {"name": "y2_scaled", "units": "dimensionless", "component": "main", "type": VariableType.ALGEBRAIC} + {"name": "y2_scaled", "units": "dimensionless", "component": "main"} ] diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index ddc2826b8..d03b04f92 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -13,29 +13,29 @@ const size_t CONSTANT_COUNT = 2; const size_t COMPUTED_CONSTANT_COUNT = 5; const size_t ALGEBRAIC_COUNT = 3; -const VariableInfo VOI_INFO = {"x", "dimensionless", "main", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"x", "dimensionless", "main"}; const VariableInfo STATE_INFO[] = { - {"sin", "dimensionless", "deriv_approx_sin", STATE} + {"sin", "dimensionless", "deriv_approx_sin"} }; const VariableInfo CONSTANT_INFO[] = { - {"deriv_approx_initial_value", "dimensionless", "main", CONSTANT}, - {"C", "dimensionless", "main", CONSTANT} + {"deriv_approx_initial_value", "dimensionless", "main"}, + {"C", "dimensionless", "main"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"k2_oPi", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, - {"k2Pi", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, - {"kPi_2", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, - {"kPi", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT}, - {"kPi_32", "dimensionless", "parabolic_approx_sin", COMPUTED_CONSTANT} + {"k2_oPi", "dimensionless", "parabolic_approx_sin"}, + {"k2Pi", "dimensionless", "parabolic_approx_sin"}, + {"kPi_2", "dimensionless", "parabolic_approx_sin"}, + {"kPi", "dimensionless", "parabolic_approx_sin"}, + {"kPi_32", "dimensionless", "parabolic_approx_sin"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"sin", "dimensionless", "actual_sin", ALGEBRAIC}, - {"sin", "dimensionless", "parabolic_approx_sin", ALGEBRAIC}, - {"z", "dimensionless", "parabolic_approx_sin", ALGEBRAIC} + {"sin", "dimensionless", "actual_sin"}, + {"sin", "dimensionless", "parabolic_approx_sin"}, + {"z", "dimensionless", "parabolic_approx_sin"} }; double * createStatesArray() diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index fa49280dc..67daeb345 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[27]; char units[14]; char component[21]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index ed86aa9c5..73c276d42 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -12,37 +12,28 @@ COMPUTED_CONSTANT_COUNT = 5 ALGEBRAIC_COUNT = 3 +VOI_INFO = {"name": "x", "units": "dimensionless", "component": "main"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "x", "units": "dimensionless", "component": "main", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "sin", "units": "dimensionless", "component": "deriv_approx_sin", "type": VariableType.STATE} +STATE_INFO = {"name": "sin", "units": "dimensionless", "component": "deriv_approx_sin"} CONSTANT_INFO = [ - {"name": "deriv_approx_initial_value", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT}, - {"name": "C", "units": "dimensionless", "component": "main", "type": VariableType.CONSTANT} + {"name": "deriv_approx_initial_value", "units": "dimensionless", "component": "main"}, + {"name": "C", "units": "dimensionless", "component": "main"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "k2_oPi", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "k2Pi", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "kPi_2", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "kPi", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT}, - {"name": "kPi_32", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.COMPUTED_CONSTANT} + {"name": "k2_oPi", "units": "dimensionless", "component": "parabolic_approx_sin"}, + {"name": "k2Pi", "units": "dimensionless", "component": "parabolic_approx_sin"}, + {"name": "kPi_2", "units": "dimensionless", "component": "parabolic_approx_sin"}, + {"name": "kPi", "units": "dimensionless", "component": "parabolic_approx_sin"}, + {"name": "kPi_32", "units": "dimensionless", "component": "parabolic_approx_sin"} ] ALGEBRAIC_INFO = [ - {"name": "sin", "units": "dimensionless", "component": "actual_sin", "type": VariableType.ALGEBRAIC}, - {"name": "sin", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.ALGEBRAIC}, - {"name": "z", "units": "dimensionless", "component": "parabolic_approx_sin", "type": VariableType.ALGEBRAIC} + {"name": "sin", "units": "dimensionless", "component": "actual_sin"}, + {"name": "sin", "units": "dimensionless", "component": "parabolic_approx_sin"}, + {"name": "z", "units": "dimensionless", "component": "parabolic_approx_sin"} ] diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 8fb19598c..7ca1689b4 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -14,25 +14,25 @@ const size_t ALGEBRAIC_COUNT = 1; const size_t EXTERNAL_COUNT = 1; const VariableInfo CONSTANT_INFO[] = { - {"E", "fmol", "SLC_template3_ss", CONSTANT}, - {"P_0", "per_fmol_sec4", "SLC_template3_ss", CONSTANT}, - {"q_Ao", "fmol", "SLC_template3_ss", CONSTANT}, - {"P_1", "per_fmol_sec4", "SLC_template3_ss", CONSTANT}, - {"q_Ai", "fmol", "SLC_template3_ss", CONSTANT}, - {"P_2", "per_fmol_sec3", "SLC_template3_ss", CONSTANT}, - {"P_5", "per_sec3", "SLC_template3_ss", CONSTANT}, - {"P_4", "per_fmol2_sec3", "SLC_template3_ss", CONSTANT} + {"E", "fmol", "SLC_template3_ss"}, + {"P_0", "per_fmol_sec4", "SLC_template3_ss"}, + {"q_Ao", "fmol", "SLC_template3_ss"}, + {"P_1", "per_fmol_sec4", "SLC_template3_ss"}, + {"q_Ai", "fmol", "SLC_template3_ss"}, + {"P_2", "per_fmol_sec3", "SLC_template3_ss"}, + {"P_5", "per_sec3", "SLC_template3_ss"}, + {"P_4", "per_fmol2_sec3", "SLC_template3_ss"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"v", "fmol_per_sec", "SLC_template3_ss", ALGEBRAIC} + {"v", "fmol_per_sec", "SLC_template3_ss"} }; const VariableInfo EXTERNAL_INFO[] = { - {"P_3", "per_fmol_sec3", "SLC_template3_ss", EXTERNAL} + {"P_3", "per_fmol_sec3", "SLC_template3_ss"} }; double * createVariablesArray() diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 19a59cbdf..5cbdcf0fb 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -12,18 +12,10 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; extern const size_t EXTERNAL_COUNT; -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - typedef struct { char name[5]; char units[15]; char component[17]; - VariableType type; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index f0888ac18..6b40d05ec 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -12,34 +12,26 @@ ALGEBRAIC_COUNT = 1 EXTERNAL_COUNT = 1 - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - EXTERNAL = 3 - - CONSTANT_INFO = [ - {"name": "E", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "q_Ao", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_1", "units": "per_fmol_sec4", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "q_Ai", "units": "fmol", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_2", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT}, - {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss", "type": VariableType.CONSTANT} + {"name": "E", "units": "fmol", "component": "SLC_template3_ss"}, + {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, + {"name": "q_Ao", "units": "fmol", "component": "SLC_template3_ss"}, + {"name": "P_1", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, + {"name": "q_Ai", "units": "fmol", "component": "SLC_template3_ss"}, + {"name": "P_2", "units": "per_fmol_sec3", "component": "SLC_template3_ss"}, + {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss"}, + {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss"} ] COMPUTED_CONSTANT_INFO = [ ] ALGEBRAIC_INFO = [ - {"name": "v", "units": "fmol_per_sec", "component": "SLC_template3_ss", "type": VariableType.ALGEBRAIC} + {"name": "v", "units": "fmol_per_sec", "component": "SLC_template3_ss"} ] EXTERNAL_INFO = [ - {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss", "type": VariableType.EXTERNAL} + {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss"} ] diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index eecc37c61..f07d91112 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -13,14 +13,14 @@ const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; const size_t ALGEBRAIC_COUNT = 0; -const VariableInfo VOI_INFO = {"t", "second", "component_1", VARIABLE_OF_INTEGRATION}; +const VariableInfo VOI_INFO = {"t", "second", "component_1"}; const VariableInfo STATE_INFO[] = { - {"X", "dimensionless", "component_1", STATE} + {"X", "dimensionless", "component_1"} }; const VariableInfo CONSTANT_INFO[] = { - {"X_init", "dimensionless", "component_2", CONSTANT} + {"X_init", "dimensionless", "component_2"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index 0db53022c..401821925 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -12,19 +12,10 @@ extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; -typedef enum { - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC -} VariableType; - typedef struct { char name[7]; char units[14]; char component[12]; - VariableType type; } VariableInfo; extern const VariableInfo VOI_INFO; diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index a2dd6a166..c532e1007 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -12,22 +12,13 @@ COMPUTED_CONSTANT_COUNT = 0 ALGEBRAIC_COUNT = 0 +VOI_INFO = {"name": "t", "units": "second", "component": "component_1"} -class VariableType(Enum): - VARIABLE_OF_INTEGRATION = 0 - STATE = 1 - CONSTANT = 2 - COMPUTED_CONSTANT = 3 - ALGEBRAIC = 4 - - -VOI_INFO = {"name": "t", "units": "second", "component": "component_1", "type": VariableType.VARIABLE_OF_INTEGRATION} - -STATE_INFO = {"name": "X", "units": "dimensionless", "component": "component_1", "type": VariableType.STATE} +STATE_INFO = {"name": "X", "units": "dimensionless", "component": "component_1"} CONSTANT_INFO = [ - {"name": "X_init", "units": "dimensionless", "component": "component_2", "type": VariableType.CONSTANT} + {"name": "X_init", "units": "dimensionless", "component": "component_2"} ] COMPUTED_CONSTANT_INFO = [ From 330f6d63a3c5a9a608ccfb28d5db5c81dcc2f79d Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 14 Aug 2024 16:07:08 +0200 Subject: [PATCH 21/74] GeneratorProfile: extracted generator profile_p.h. --- src/CMakeLists.txt | 1 + src/generator.cpp | 6 +- src/generatorprofile.cpp | 282 +----------------------------------- src/generatorprofile_p.h | 302 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 307 insertions(+), 284 deletions(-) create mode 100644 src/generatorprofile_p.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index eb748bf9a..82d4676d1 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -133,6 +133,7 @@ set(GIT_HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/debug.h ${CMAKE_CURRENT_SOURCE_DIR}/entity_p.h ${CMAKE_CURRENT_SOURCE_DIR}/generator_p.h + ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofile_p.h ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofilesha1values.h ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofiletools.h ${CMAKE_CURRENT_SOURCE_DIR}/internaltypes.h diff --git a/src/generator.cpp b/src/generator.cpp index 4c7b02d81..cf994f3e8 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -390,9 +390,9 @@ std::string Generator::GeneratorImpl::generateVariableInfoEntryCode(const std::s const std::string &component) const { return replace(replace(replace(mProfile->variableInfoEntryString(), - "[NAME]", name), - "[UNITS]", units), - "[COMPONENT]", component); + "[NAME]", name), + "[UNITS]", units), + "[COMPONENT]", component); } void Generator::GeneratorImpl::addInterfaceVariableInfoCode() diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 843249297..2655cce43 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -22,291 +22,11 @@ limitations under the License. #include +#include "generatorprofile_p.h" #include "utilities.h" namespace libcellml { -/** - * @brief The GeneratorProfile::GeneratorProfileImpl struct. - * - * The private implementation for the GeneratorProfile class. - */ -struct GeneratorProfile::GeneratorProfileImpl -{ - // Whether the profile is official. - - GeneratorProfile::Profile mProfile = Profile::C; - - // Whether the profile requires an interface to be generated. - - bool mHasInterface = true; - - // Equality. - - std::string mEqualityString; - - // Relational and logical operators. - - std::string mEqString; - std::string mNeqString; - std::string mLtString; - std::string mLeqString; - std::string mGtString; - std::string mGeqString; - std::string mAndString; - std::string mOrString; - std::string mXorString; - std::string mNotString; - - bool mHasEqOperator = true; - bool mHasNeqOperator = true; - bool mHasLtOperator = true; - bool mHasLeqOperator = true; - bool mHasGtOperator = true; - bool mHasGeqOperator = true; - bool mHasAndOperator = true; - bool mHasOrOperator = true; - bool mHasXorOperator = true; - bool mHasNotOperator = true; - - // Arithmetic operators. - - std::string mPlusString; - std::string mMinusString; - std::string mTimesString; - std::string mDivideString; - std::string mPowerString; - std::string mSquareRootString; - std::string mSquareString; - std::string mAbsoluteValueString; - std::string mExponentialString; - std::string mNaturalLogarithmString; - std::string mCommonLogarithmString; - std::string mCeilingString; - std::string mFloorString; - std::string mMinString; - std::string mMaxString; - std::string mRemString; - - bool mHasPowerOperator = false; - - // Trigonometric operators. - - std::string mSinString; - std::string mCosString; - std::string mTanString; - std::string mSecString; - std::string mCscString; - std::string mCotString; - std::string mSinhString; - std::string mCoshString; - std::string mTanhString; - std::string mSechString; - std::string mCschString; - std::string mCothString; - std::string mAsinString; - std::string mAcosString; - std::string mAtanString; - std::string mAsecString; - std::string mAcscString; - std::string mAcotString; - std::string mAsinhString; - std::string mAcoshString; - std::string mAtanhString; - std::string mAsechString; - std::string mAcschString; - std::string mAcothString; - - // Piecewise statement. - - std::string mConditionalOperatorIfString; - std::string mConditionalOperatorElseString; - std::string mPiecewiseIfString; - std::string mPiecewiseElseString; - - bool mHasConditionalOperator = true; - - // Constants. - - std::string mTrueString; - std::string mFalseString; - std::string mEString; - std::string mPiString; - std::string mInfString; - std::string mNanString; - - // Arithmetic functions. - - std::string mEqFunctionString; - std::string mNeqFunctionString; - std::string mLtFunctionString; - std::string mLeqFunctionString; - std::string mGtFunctionString; - std::string mGeqFunctionString; - std::string mAndFunctionString; - std::string mOrFunctionString; - std::string mXorFunctionString; - std::string mNotFunctionString; - std::string mMinFunctionString; - std::string mMaxFunctionString; - - // Trigonometric functions. - - std::string mSecFunctionString; - std::string mCscFunctionString; - std::string mCotFunctionString; - std::string mSechFunctionString; - std::string mCschFunctionString; - std::string mCothFunctionString; - std::string mAsecFunctionString; - std::string mAcscFunctionString; - std::string mAcotFunctionString; - std::string mAsechFunctionString; - std::string mAcschFunctionString; - std::string mAcothFunctionString; - - // Miscellaneous. - - std::string mCommentString; - std::string mOriginCommentString; - - std::string mInterfaceFileNameString; - - std::string mInterfaceHeaderString; - std::string mImplementationHeaderString; - - std::string mInterfaceVersionString; - std::string mImplementationVersionString; - - std::string mInterfaceLibcellmlVersionString; - std::string mImplementationLibcellmlVersionString; - - std::string mInterfaceStateCountString; - std::string mImplementationStateCountString; - - std::string mInterfaceConstantCountString; - std::string mImplementationConstantCountString; - - std::string mInterfaceComputedConstantCountString; - std::string mImplementationComputedConstantCountString; - - std::string mInterfaceAlgebraicCountString; - std::string mImplementationAlgebraicCountString; - - std::string mInterfaceExternalCountString; - std::string mImplementationExternalCountString; - - std::string mVariableInfoObjectString; - - std::string mInterfaceVoiInfoString; - std::string mImplementationVoiInfoString; - - std::string mInterfaceStateInfoString; - std::string mImplementationStateInfoString; - - std::string mInterfaceConstantInfoString; - std::string mImplementationConstantInfoString; - - std::string mInterfaceComputedConstantInfoString; - std::string mImplementationComputedConstantInfoString; - - std::string mInterfaceAlgebraicInfoString; - std::string mImplementationAlgebraicInfoString; - - std::string mInterfaceExternalInfoString; - std::string mImplementationExternalInfoString; - - std::string mVariableInfoEntryString; - - std::string mVoiString; - - std::string mStatesArrayString; - std::string mRatesArrayString; - std::string mConstantsArrayString; - std::string mComputedConstantsArrayString; - std::string mAlgebraicArrayString; - - std::string mExternalVariableMethodTypeDefinitionFamString; - std::string mExternalVariableMethodTypeDefinitionFdmString; - - std::string mExternalVariableMethodCallFamString; - std::string mExternalVariableMethodCallFdmString; - - std::string mRootFindingInfoObjectFamString; - std::string mRootFindingInfoObjectFdmString; - std::string mExternNlaSolveMethodString; - std::string mFindRootCallFamString; - std::string mFindRootCallFdmString; - std::string mFindRootMethodFamString; - std::string mFindRootMethodFdmString; - std::string mNlaSolveCallFamString; - std::string mNlaSolveCallFdmString; - std::string mObjectiveFunctionMethodFamString; - std::string mObjectiveFunctionMethodFdmString; - std::string mUArrayString; - std::string mFArrayString; - - std::string mInterfaceCreateStatesArrayMethodString; - std::string mImplementationCreateStatesArrayMethodString; - - std::string mInterfaceCreateVariablesArrayMethodString; - std::string mImplementationCreateVariablesArrayMethodString; - - std::string mInterfaceDeleteArrayMethodString; - std::string mImplementationDeleteArrayMethodString; - - std::string mInterfaceInitialiseVariablesMethodFamWoevString; - std::string mImplementationInitialiseVariablesMethodFamWoevString; - - std::string mInterfaceInitialiseVariablesMethodFamWevString; - std::string mImplementationInitialiseVariablesMethodFamWevString; - - std::string mInterfaceInitialiseVariablesMethodFdmWoevString; - std::string mImplementationInitialiseVariablesMethodFdmWoevString; - - std::string mInterfaceInitialiseVariablesMethodFdmWevString; - std::string mImplementationInitialiseVariablesMethodFdmWevString; - - std::string mInterfaceComputeComputedConstantsMethodString; - std::string mImplementationComputeComputedConstantsMethodString; - - std::string mInterfaceComputeRatesMethodWoevString; - std::string mImplementationComputeRatesMethodWoevString; - - std::string mInterfaceComputeRatesMethodWevString; - std::string mImplementationComputeRatesMethodWevString; - - std::string mInterfaceComputeVariablesMethodFamWoevString; - std::string mImplementationComputeVariablesMethodFamWoevString; - - std::string mInterfaceComputeVariablesMethodFamWevString; - std::string mImplementationComputeVariablesMethodFamWevString; - - std::string mInterfaceComputeVariablesMethodFdmWoevString; - std::string mImplementationComputeVariablesMethodFdmWoevString; - - std::string mInterfaceComputeVariablesMethodFdmWevString; - std::string mImplementationComputeVariablesMethodFdmWevString; - - std::string mEmptyMethodString; - - std::string mIndentString; - - std::string mOpenArrayInitialiserString; - std::string mCloseArrayInitialiserString; - - std::string mOpenArrayString; - std::string mCloseArrayString; - - std::string mArrayElementSeparatorString; - - std::string mStringDelimiterString; - - std::string mCommandSeparatorString; - - void loadProfile(GeneratorProfile::Profile profile); -}; - void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profile profile) { mProfile = profile; diff --git a/src/generatorprofile_p.h b/src/generatorprofile_p.h new file mode 100644 index 000000000..e87a24da7 --- /dev/null +++ b/src/generatorprofile_p.h @@ -0,0 +1,302 @@ +/* +Copyright libCellML Contributors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include "libcellml/generatorprofile.h" + +namespace libcellml { + +/** + * @brief The GeneratorProfile::GeneratorProfileImpl struct. + * + * The private implementation for the GeneratorProfile class. + */ +struct GeneratorProfile::GeneratorProfileImpl +{ + // Whether the profile is official. + + GeneratorProfile::Profile mProfile = Profile::C; + + // Whether the profile requires an interface to be generated. + + bool mHasInterface = true; + + // Equality. + + std::string mEqualityString; + + // Relational and logical operators. + + std::string mEqString; + std::string mNeqString; + std::string mLtString; + std::string mLeqString; + std::string mGtString; + std::string mGeqString; + std::string mAndString; + std::string mOrString; + std::string mXorString; + std::string mNotString; + + bool mHasEqOperator = true; + bool mHasNeqOperator = true; + bool mHasLtOperator = true; + bool mHasLeqOperator = true; + bool mHasGtOperator = true; + bool mHasGeqOperator = true; + bool mHasAndOperator = true; + bool mHasOrOperator = true; + bool mHasXorOperator = true; + bool mHasNotOperator = true; + + // Arithmetic operators. + + std::string mPlusString; + std::string mMinusString; + std::string mTimesString; + std::string mDivideString; + std::string mPowerString; + std::string mSquareRootString; + std::string mSquareString; + std::string mAbsoluteValueString; + std::string mExponentialString; + std::string mNaturalLogarithmString; + std::string mCommonLogarithmString; + std::string mCeilingString; + std::string mFloorString; + std::string mMinString; + std::string mMaxString; + std::string mRemString; + + bool mHasPowerOperator = false; + + // Trigonometric operators. + + std::string mSinString; + std::string mCosString; + std::string mTanString; + std::string mSecString; + std::string mCscString; + std::string mCotString; + std::string mSinhString; + std::string mCoshString; + std::string mTanhString; + std::string mSechString; + std::string mCschString; + std::string mCothString; + std::string mAsinString; + std::string mAcosString; + std::string mAtanString; + std::string mAsecString; + std::string mAcscString; + std::string mAcotString; + std::string mAsinhString; + std::string mAcoshString; + std::string mAtanhString; + std::string mAsechString; + std::string mAcschString; + std::string mAcothString; + + // Piecewise statement. + + std::string mConditionalOperatorIfString; + std::string mConditionalOperatorElseString; + std::string mPiecewiseIfString; + std::string mPiecewiseElseString; + + bool mHasConditionalOperator = true; + + // Constants. + + std::string mTrueString; + std::string mFalseString; + std::string mEString; + std::string mPiString; + std::string mInfString; + std::string mNanString; + + // Arithmetic functions. + + std::string mEqFunctionString; + std::string mNeqFunctionString; + std::string mLtFunctionString; + std::string mLeqFunctionString; + std::string mGtFunctionString; + std::string mGeqFunctionString; + std::string mAndFunctionString; + std::string mOrFunctionString; + std::string mXorFunctionString; + std::string mNotFunctionString; + std::string mMinFunctionString; + std::string mMaxFunctionString; + + // Trigonometric functions. + + std::string mSecFunctionString; + std::string mCscFunctionString; + std::string mCotFunctionString; + std::string mSechFunctionString; + std::string mCschFunctionString; + std::string mCothFunctionString; + std::string mAsecFunctionString; + std::string mAcscFunctionString; + std::string mAcotFunctionString; + std::string mAsechFunctionString; + std::string mAcschFunctionString; + std::string mAcothFunctionString; + + // Miscellaneous. + + std::string mCommentString; + std::string mOriginCommentString; + + std::string mInterfaceFileNameString; + + std::string mInterfaceHeaderString; + std::string mImplementationHeaderString; + + std::string mInterfaceVersionString; + std::string mImplementationVersionString; + + std::string mInterfaceLibcellmlVersionString; + std::string mImplementationLibcellmlVersionString; + + std::string mInterfaceStateCountString; + std::string mImplementationStateCountString; + + std::string mInterfaceConstantCountString; + std::string mImplementationConstantCountString; + + std::string mInterfaceComputedConstantCountString; + std::string mImplementationComputedConstantCountString; + + std::string mInterfaceAlgebraicCountString; + std::string mImplementationAlgebraicCountString; + + std::string mInterfaceExternalCountString; + std::string mImplementationExternalCountString; + + std::string mVariableInfoObjectString; + + std::string mInterfaceVoiInfoString; + std::string mImplementationVoiInfoString; + + std::string mInterfaceStateInfoString; + std::string mImplementationStateInfoString; + + std::string mInterfaceConstantInfoString; + std::string mImplementationConstantInfoString; + + std::string mInterfaceComputedConstantInfoString; + std::string mImplementationComputedConstantInfoString; + + std::string mInterfaceAlgebraicInfoString; + std::string mImplementationAlgebraicInfoString; + + std::string mInterfaceExternalInfoString; + std::string mImplementationExternalInfoString; + + std::string mVariableInfoEntryString; + + std::string mVoiString; + + std::string mStatesArrayString; + std::string mRatesArrayString; + std::string mConstantsArrayString; + std::string mComputedConstantsArrayString; + std::string mAlgebraicArrayString; + + std::string mExternalVariableMethodTypeDefinitionFamString; + std::string mExternalVariableMethodTypeDefinitionFdmString; + + std::string mExternalVariableMethodCallFamString; + std::string mExternalVariableMethodCallFdmString; + + std::string mRootFindingInfoObjectFamString; + std::string mRootFindingInfoObjectFdmString; + std::string mExternNlaSolveMethodString; + std::string mFindRootCallFamString; + std::string mFindRootCallFdmString; + std::string mFindRootMethodFamString; + std::string mFindRootMethodFdmString; + std::string mNlaSolveCallFamString; + std::string mNlaSolveCallFdmString; + std::string mObjectiveFunctionMethodFamString; + std::string mObjectiveFunctionMethodFdmString; + std::string mUArrayString; + std::string mFArrayString; + + std::string mInterfaceCreateStatesArrayMethodString; + std::string mImplementationCreateStatesArrayMethodString; + + std::string mInterfaceCreateVariablesArrayMethodString; + std::string mImplementationCreateVariablesArrayMethodString; + + std::string mInterfaceDeleteArrayMethodString; + std::string mImplementationDeleteArrayMethodString; + + std::string mInterfaceInitialiseVariablesMethodFamWoevString; + std::string mImplementationInitialiseVariablesMethodFamWoevString; + + std::string mInterfaceInitialiseVariablesMethodFamWevString; + std::string mImplementationInitialiseVariablesMethodFamWevString; + + std::string mInterfaceInitialiseVariablesMethodFdmWoevString; + std::string mImplementationInitialiseVariablesMethodFdmWoevString; + + std::string mInterfaceInitialiseVariablesMethodFdmWevString; + std::string mImplementationInitialiseVariablesMethodFdmWevString; + + std::string mInterfaceComputeComputedConstantsMethodString; + std::string mImplementationComputeComputedConstantsMethodString; + + std::string mInterfaceComputeRatesMethodWoevString; + std::string mImplementationComputeRatesMethodWoevString; + + std::string mInterfaceComputeRatesMethodWevString; + std::string mImplementationComputeRatesMethodWevString; + + std::string mInterfaceComputeVariablesMethodFamWoevString; + std::string mImplementationComputeVariablesMethodFamWoevString; + + std::string mInterfaceComputeVariablesMethodFamWevString; + std::string mImplementationComputeVariablesMethodFamWevString; + + std::string mInterfaceComputeVariablesMethodFdmWoevString; + std::string mImplementationComputeVariablesMethodFdmWoevString; + + std::string mInterfaceComputeVariablesMethodFdmWevString; + std::string mImplementationComputeVariablesMethodFdmWevString; + + std::string mEmptyMethodString; + + std::string mIndentString; + + std::string mOpenArrayInitialiserString; + std::string mCloseArrayInitialiserString; + + std::string mOpenArrayString; + std::string mCloseArrayString; + + std::string mArrayElementSeparatorString; + + std::string mStringDelimiterString; + + std::string mCommandSeparatorString; + + void loadProfile(GeneratorProfile::Profile profile); +}; + +} // namespace libcellml From aaaeed39ed1b365dc2933430db7fa9aa0c0c3141 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 14 Aug 2024 16:31:42 +0200 Subject: [PATCH 22/74] Generator: updated the createXxxArray() methods. --- src/api/libcellml/generatorprofile.h | 171 ++++++++++++++++-- src/bindings/interface/generatorprofile.i | 62 ++++++- src/bindings/javascript/generatorprofile.cpp | 20 +- src/generator.cpp | 76 +++++--- src/generator_p.h | 5 +- src/generatorprofile.cpp | 143 +++++++++++++-- src/generatorprofile_p.h | 13 +- src/generatorprofilesha1values.h | 4 +- src/generatorprofiletools.cpp | 13 +- tests/bindings/javascript/generator.test.js | 4 +- .../javascript/generatorprofile.test.js | 48 ++++- .../bindings/python/test_generator_profile.py | 78 +++++++- tests/coverage/coverage.cpp | 8 +- tests/generator/generatorprofile.cpp | 120 +++++++++--- tests/resources/coverage/generator/model.c | 28 ++- tests/resources/coverage/generator/model.h | 5 +- .../generator/model.implementation.out | 28 ++- .../coverage/generator/model.interface.out | 5 +- .../generator/model.modified.profile.c | 28 ++- .../generator/model.modified.profile.h | 5 +- .../generator/model.modified.profile.py | 12 +- tests/resources/coverage/generator/model.py | 12 +- .../algebraic_eqn_computed_var_on_rhs/model.c | 28 ++- .../model.external.c | 39 +++- .../model.external.h | 6 +- .../model.external.py | 16 +- .../algebraic_eqn_computed_var_on_rhs/model.h | 5 +- .../model.py | 12 +- .../algebraic_eqn_const_var_on_rhs/model.c | 28 ++- .../algebraic_eqn_const_var_on_rhs/model.h | 5 +- .../algebraic_eqn_const_var_on_rhs/model.py | 12 +- .../algebraic_eqn_constant_on_rhs/model.c | 28 ++- .../algebraic_eqn_constant_on_rhs/model.h | 5 +- .../algebraic_eqn_constant_on_rhs/model.py | 12 +- .../algebraic_eqn_derivative_on_rhs/model.c | 28 ++- .../algebraic_eqn_derivative_on_rhs/model.h | 5 +- .../algebraic_eqn_derivative_on_rhs/model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../algebraic_eqn_state_var_on_rhs/model.c | 28 ++- .../algebraic_eqn_state_var_on_rhs/model.h | 5 +- .../algebraic_eqn_state_var_on_rhs/model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../model.c | 28 ++- .../model.external.c | 39 +++- .../model.external.h | 6 +- .../model.external.py | 16 +- .../model.h | 5 +- .../model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../model.three.externals.c | 39 +++- .../model.three.externals.h | 6 +- .../model.three.externals.py | 16 +- .../model.not.ordered.c | 28 ++- .../model.not.ordered.h | 5 +- .../model.not.ordered.py | 12 +- .../model.ordered.c | 28 ++- .../model.ordered.h | 5 +- .../model.ordered.py | 12 +- .../algebraic_unknown_var_on_rhs/model.c | 28 ++- .../algebraic_unknown_var_on_rhs/model.h | 5 +- .../algebraic_unknown_var_on_rhs/model.py | 12 +- .../generator/cell_geometry_model/model.c | 28 ++- .../cell_geometry_model/model.external.c | 39 +++- .../cell_geometry_model/model.external.h | 6 +- .../cell_geometry_model/model.external.py | 16 +- .../generator/cell_geometry_model/model.h | 5 +- .../generator/cell_geometry_model/model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../generator/cellml_slc_example/model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../cellml_unit_scaling_constant/model.c | 28 ++- .../cellml_unit_scaling_constant/model.h | 5 +- .../cellml_unit_scaling_constant/model.py | 12 +- .../cellml_unit_scaling_rate/model.c | 28 ++- .../cellml_unit_scaling_rate/model.h | 5 +- .../cellml_unit_scaling_rate/model.py | 12 +- .../cellml_unit_scaling_state/model.c | 28 ++- .../cellml_unit_scaling_state/model.h | 5 +- .../cellml_unit_scaling_state/model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../cellml_unit_scaling_voi_direct/model.c | 28 ++- .../cellml_unit_scaling_voi_direct/model.h | 5 +- .../cellml_unit_scaling_voi_direct/model.py | 12 +- .../cellml_unit_scaling_voi_indirect/model.c | 28 ++- .../cellml_unit_scaling_voi_indirect/model.h | 5 +- .../cellml_unit_scaling_voi_indirect/model.py | 12 +- .../generator/dae_cellml_1_1_model/model.c | 28 ++- .../generator/dae_cellml_1_1_model/model.h | 5 +- .../generator/dae_cellml_1_1_model/model.py | 12 +- .../generator/dependent_eqns/model.c | 28 ++- .../generator/dependent_eqns/model.h | 5 +- .../generator/dependent_eqns/model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../model.algebraic.c | 39 +++- .../model.algebraic.h | 6 +- .../model.algebraic.py | 16 +- .../model.c | 28 ++- .../model.computed.constant.c | 39 +++- .../model.computed.constant.h | 6 +- .../model.computed.constant.py | 16 +- .../model.constant.c | 39 +++- .../model.constant.h | 6 +- .../model.constant.py | 16 +- .../model.dae.c | 28 ++- .../model.dae.h | 5 +- .../model.dae.py | 12 +- .../model.dependent.algebraic.c | 39 +++- .../model.dependent.algebraic.h | 6 +- .../model.dependent.algebraic.py | 16 +- .../model.dependent.computed.constant.c | 39 +++- .../model.dependent.computed.constant.h | 6 +- .../model.dependent.computed.constant.py | 16 +- .../model.dependent.constant.c | 39 +++- .../model.dependent.constant.h | 6 +- .../model.dependent.constant.py | 16 +- .../model.dependent.state.c | 39 +++- .../model.dependent.state.h | 6 +- .../model.dependent.state.py | 16 +- .../model.external.c | 39 +++- .../model.external.h | 6 +- .../model.external.py | 16 +- .../model.h | 5 +- .../model.py | 12 +- .../model.state.c | 39 +++- .../model.state.h | 6 +- .../model.state.py | 16 +- .../generator/noble_model_1962/model.c | 28 ++- .../generator/noble_model_1962/model.h | 5 +- .../generator/noble_model_1962/model.py | 12 +- .../generator/ode_computed_var_on_rhs/model.c | 28 ++- .../generator/ode_computed_var_on_rhs/model.h | 5 +- .../ode_computed_var_on_rhs/model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../generator/ode_const_var_on_rhs/model.c | 28 ++- .../generator/ode_const_var_on_rhs/model.h | 5 +- .../generator/ode_const_var_on_rhs/model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../generator/ode_constant_on_rhs/model.c | 28 ++- .../generator/ode_constant_on_rhs/model.h | 5 +- .../generator/ode_constant_on_rhs/model.py | 12 +- .../ode_constant_on_rhs_one_component/model.c | 28 ++- .../ode_constant_on_rhs_one_component/model.h | 5 +- .../model.py | 12 +- .../ode_multiple_dependent_odes/model.c | 28 ++- .../ode_multiple_dependent_odes/model.h | 5 +- .../ode_multiple_dependent_odes/model.py | 12 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- .../ode_multiple_odes_with_same_name/model.c | 28 ++- .../ode_multiple_odes_with_same_name/model.h | 5 +- .../ode_multiple_odes_with_same_name/model.py | 12 +- .../generator/ode_unknown_var_on_rhs/model.c | 28 ++- .../generator/ode_unknown_var_on_rhs/model.h | 5 +- .../generator/ode_unknown_var_on_rhs/model.py | 12 +- .../robertson_model_1966/model.dae.c | 28 ++- .../robertson_model_1966/model.dae.h | 5 +- .../robertson_model_1966/model.dae.py | 12 +- .../robertson_model_1966/model.ode.c | 28 ++- .../robertson_model_1966/model.ode.h | 5 +- .../robertson_model_1966/model.ode.py | 12 +- .../generator/sine_model_imports/model.c | 28 ++- .../generator/sine_model_imports/model.h | 5 +- .../generator/sine_model_imports/model.py | 12 +- .../model.c | 39 +++- .../model.h | 6 +- .../model.py | 16 +- .../model.c | 28 ++- .../model.h | 5 +- .../model.py | 12 +- 194 files changed, 3195 insertions(+), 494 deletions(-) diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index 69a00d263..943eca801 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -3447,49 +3447,180 @@ class LIBCELLML_EXPORT GeneratorProfile void setImplementationCreateStatesArrayMethodString(const std::string &implementationCreateStatesArrayMethodString); /** - * @brief Get the @c std::string for the interface to create variables + * @brief Get the @c std::string for the interface to create the constants * array. * - * Return the @c std::string for the interface to create variables array. + * Return the @c std::string for the interface to create the constants array. * - * @return The @c std::string for the interface to create variables array. + * @return The @c std::string for the interface to create the constants array. */ - std::string interfaceCreateVariablesArrayMethodString() const; + std::string interfaceCreateConstantsArrayMethodString() const; /** - * @brief Set the @c std::string for the interface to create variables + * @brief Set the @c std::string for the interface to create the constants * array. * - * Set the @c std::string for the interface to create variables array. + * Set the @c std::string for the interface to create the constants array. * - * @param interfaceCreateVariablesArrayMethodString The @c std::string to - * use for the interface to create variables array. + * @param interfaceCreateConstantsArrayMethodString The @c std::string to use + * for the interface to create the constants array. */ - void setInterfaceCreateVariablesArrayMethodString(const std::string &interfaceCreateVariablesArrayMethodString); + void setInterfaceCreateConstantsArrayMethodString(const std::string &interfaceCreateConstantsArrayMethodString); /** - * @brief Get the @c std::string for the implementation to create the - * variables array. + * @brief Get the @c std::string for the implementation to create the constants + * array. + * + * Return the @c std::string for the implementation to create the constants + * array. + * + * @return The @c std::string for the implementation to create the constants + * array. + */ + std::string implementationCreateConstantsArrayMethodString() const; + + /** + * @brief Set the @c std::string for the implementation to create the constants + * array. + * + * Set the @c std::string for the implementation to create the constants array. + * + * @param implementationCreateConstantsArrayMethodString The @c std::string to + * use for the implementation to create the constants array. + */ + void setImplementationCreateConstantsArrayMethodString(const std::string &implementationCreateConstantsArrayMethodString); + + /** + * @brief Get the @c std::string for the interface to create the computed constants + * array. + * + * Return the @c std::string for the interface to create the computed constants array. + * + * @return The @c std::string for the interface to create the computed constants array. + */ + std::string interfaceCreateComputedConstantsArrayMethodString() const; + + /** + * @brief Set the @c std::string for the interface to create the computed constants + * array. + * + * Set the @c std::string for the interface to create the computed constants array. + * + * @param interfaceCreateComputedConstantsArrayMethodString The @c std::string to use + * for the interface to create the computed constants array. + */ + void setInterfaceCreateComputedConstantsArrayMethodString(const std::string &interfaceCreateComputedConstantsArrayMethodString); + + /** + * @brief Get the @c std::string for the implementation to create the computed constants + * array. * - * Return the @c std::string for the implementation to create the variables + * Return the @c std::string for the implementation to create the computed constants * array. * - * @return The @c std::string for the implementation to create the variables + * @return The @c std::string for the implementation to create the computed constants + * array. + */ + std::string implementationCreateComputedConstantsArrayMethodString() const; + + /** + * @brief Set the @c std::string for the implementation to create the computed constants * array. + * + * Set the @c std::string for the implementation to create the computed constants array. + * + * @param implementationCreateComputedConstantsArrayMethodString The @c std::string to + * use for the implementation to create the computed constants array. */ - std::string implementationCreateVariablesArrayMethodString() const; + void setImplementationCreateComputedConstantsArrayMethodString(const std::string &implementationCreateComputedConstantsArrayMethodString); /** - * @brief Set the @c std::string for the implementation to create the - * variables array. + * @brief Get the @c std::string for the interface to create the algebraic variables + * array. + * + * Return the @c std::string for the interface to create the algebraic variables array. * - * Set the @c std::string for the implementation to create the variables + * @return The @c std::string for the interface to create the algebraic variables array. + */ + std::string interfaceCreateAlgebraicArrayMethodString() const; + + /** + * @brief Set the @c std::string for the interface to create the algebraic variables * array. * - * @param implementationCreateVariablesArrayMethodString The @c std::string - * to use for the implementation to create the variables array. + * Set the @c std::string for the interface to create the algebraic variables array. + * + * @param interfaceCreateAlgebraicArrayMethodString The @c std::string to use + * for the interface to create the algebraic variables array. + */ + void setInterfaceCreateAlgebraicArrayMethodString(const std::string &interfaceCreateAlgebraicArrayMethodString); + + /** + * @brief Get the @c std::string for the implementation to create the algebraic variables + * array. + * + * Return the @c std::string for the implementation to create the algebraic variables + * array. + * + * @return The @c std::string for the implementation to create the algebraic variables + * array. + */ + std::string implementationCreateAlgebraicArrayMethodString() const; + + /** + * @brief Set the @c std::string for the implementation to create the algebraic variables + * array. + * + * Set the @c std::string for the implementation to create the algebraic variables array. + * + * @param implementationCreateAlgebraicArrayMethodString The @c std::string to + * use for the implementation to create the algebraic variables array. + */ + void setImplementationCreateAlgebraicArrayMethodString(const std::string &implementationCreateAlgebraicArrayMethodString); + + /** + * @brief Get the @c std::string for the interface to create the external variables + * array. + * + * Return the @c std::string for the interface to create the external variables array. + * + * @return The @c std::string for the interface to create the external variables array. + */ + std::string interfaceCreateExternalsArrayMethodString() const; + + /** + * @brief Set the @c std::string for the interface to create the external variables + * array. + * + * Set the @c std::string for the interface to create the external variables array. + * + * @param interfaceCreateExternalsArrayMethodString The @c std::string to use + * for the interface to create the external variables array. + */ + void setInterfaceCreateExternalsArrayMethodString(const std::string &interfaceCreateExternalsArrayMethodString); + + /** + * @brief Get the @c std::string for the implementation to create the external variables + * array. + * + * Return the @c std::string for the implementation to create the external variables + * array. + * + * @return The @c std::string for the implementation to create the external variables + * array. + */ + std::string implementationCreateExternalsArrayMethodString() const; + + /** + * @brief Set the @c std::string for the implementation to create the external variables + * array. + * + * Set the @c std::string for the implementation to create the external variables array. + * + * @param implementationCreateExternalsArrayMethodString The @c std::string to + * use for the implementation to create the external variables array. */ - void setImplementationCreateVariablesArrayMethodString(const std::string &implementationCreateVariablesArrayMethodString); + void setImplementationCreateExternalsArrayMethodString(const std::string &implementationCreateExternalsArrayMethodString); /** * @brief Get the @c std::string for the interface to delete an array. diff --git a/src/bindings/interface/generatorprofile.i b/src/bindings/interface/generatorprofile.i index 712e2198a..23fc7a9b9 100644 --- a/src/bindings/interface/generatorprofile.i +++ b/src/bindings/interface/generatorprofile.i @@ -938,19 +938,61 @@ tag, which will be replaced with some code to create the states array."; "Sets the string for the implementation to create the states array. To be useful, the string should contain the tag, which will be replaced with some code to create the states array."; -%feature("docstring") libcellml::GeneratorProfile::interfaceCreateVariablesArrayMethodString -"Returns the string for the interface to create variables array."; +%feature("docstring") libcellml::GeneratorProfile::interfaceCreateConstantsArrayMethodString +"Returns the string for the interface to create the constants array."; -%feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateVariablesArrayMethodString -"Sets the string for the interface to create variables array. To be useful, the string should contain the -tag, which will be replaced with some code to create the variables array."; +%feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateConstantsArrayMethodString +"Sets the string for the interface to create the constants array. To be useful, the string should contain the +tag, which will be replaced with some code to create the constants array."; -%feature("docstring") libcellml::GeneratorProfile::implementationCreateVariablesArrayMethodString -"Returns the string for the implementation to create the variables array."; +%feature("docstring") libcellml::GeneratorProfile::implementationCreateConstantsArrayMethodString +"Returns the string for the implementation to create the constants array."; -%feature("docstring") libcellml::GeneratorProfile::setImplementationCreateVariablesArrayMethodString -"Sets the string for the implementation to create the variables array. To be useful, the string should contain the - tag, which will be replaced with some code to create the variables array."; +%feature("docstring") libcellml::GeneratorProfile::setImplementationCreateConstantsArrayMethodString +"Sets the string for the implementation to create the constants array. To be useful, the string should contain the + tag, which will be replaced with some code to create the constants array."; + +%feature("docstring") libcellml::GeneratorProfile::interfaceCreateComputedConstantsArrayMethodString +"Returns the string for the interface to create the computed constants array."; + +%feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateComputedConstantsArrayMethodString +"Sets the string for the interface to create the computed constants array. To be useful, the string should contain the +tag, which will be replaced with some code to create the computed constants array."; + +%feature("docstring") libcellml::GeneratorProfile::implementationCreateComputedConstantsArrayMethodString +"Returns the string for the implementation to create the computed constants array."; + +%feature("docstring") libcellml::GeneratorProfile::setImplementationCreateComputedConstantsArrayMethodString +"Sets the string for the implementation to create the computed constants array. To be useful, the string should contain the + tag, which will be replaced with some code to create the computed constants array."; + +%feature("docstring") libcellml::GeneratorProfile::interfaceCreateAlgebraicArrayMethodString +"Returns the string for the interface to create the algebraic array."; + +%feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateAlgebraicArrayMethodString +"Sets the string for the interface to create the algebraic array. To be useful, the string should contain the +tag, which will be replaced with some code to create the algebraic array."; + +%feature("docstring") libcellml::GeneratorProfile::implementationCreateAlgebraicArrayMethodString +"Returns the string for the implementation to create the algebraic array."; + +%feature("docstring") libcellml::GeneratorProfile::setImplementationCreateAlgebraicArrayMethodString +"Sets the string for the implementation to create the algebraic array. To be useful, the string should contain the + tag, which will be replaced with some code to create the algebraic array."; + +%feature("docstring") libcellml::GeneratorProfile::interfaceCreateExternalsArrayMethodString +"Returns the string for the interface to create the externals array."; + +%feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateExternalsArrayMethodString +"Sets the string for the interface to create the externals array. To be useful, the string should contain the +tag, which will be replaced with some code to create the externals array."; + +%feature("docstring") libcellml::GeneratorProfile::implementationCreateExternalsArrayMethodString +"Returns the string for the implementation to create the externals array."; + +%feature("docstring") libcellml::GeneratorProfile::setImplementationCreateExternalsArrayMethodString +"Sets the string for the implementation to create the externals array. To be useful, the string should contain the + tag, which will be replaced with some code to create the externals array."; %feature("docstring") libcellml::GeneratorProfile::interfaceDeleteArrayMethodString "Returns the string for the interface to delete an array."; diff --git a/src/bindings/javascript/generatorprofile.cpp b/src/bindings/javascript/generatorprofile.cpp index 5a28e6cac..1f4d57997 100644 --- a/src/bindings/javascript/generatorprofile.cpp +++ b/src/bindings/javascript/generatorprofile.cpp @@ -331,10 +331,22 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setInterfaceCreateStatesArrayMethodString", &libcellml::GeneratorProfile::setInterfaceCreateStatesArrayMethodString) .function("implementationCreateStatesArrayMethodString", &libcellml::GeneratorProfile::implementationCreateStatesArrayMethodString) .function("setImplementationCreateStatesArrayMethodString", &libcellml::GeneratorProfile::setImplementationCreateStatesArrayMethodString) - .function("interfaceCreateVariablesArrayMethodString", &libcellml::GeneratorProfile::interfaceCreateVariablesArrayMethodString) - .function("setInterfaceCreateVariablesArrayMethodString", &libcellml::GeneratorProfile::setInterfaceCreateVariablesArrayMethodString) - .function("implementationCreateVariablesArrayMethodString", &libcellml::GeneratorProfile::implementationCreateVariablesArrayMethodString) - .function("setImplementationCreateVariablesArrayMethodString", &libcellml::GeneratorProfile::setImplementationCreateVariablesArrayMethodString) + .function("interfaceCreateConstantsArrayMethodString", &libcellml::GeneratorProfile::interfaceCreateConstantsArrayMethodString) + .function("setInterfaceCreateConstantsArrayMethodString", &libcellml::GeneratorProfile::setInterfaceCreateConstantsArrayMethodString) + .function("implementationCreateConstantsArrayMethodString", &libcellml::GeneratorProfile::implementationCreateConstantsArrayMethodString) + .function("setImplementationCreateConstantsArrayMethodString", &libcellml::GeneratorProfile::setImplementationCreateConstantsArrayMethodString) + .function("interfaceCreateComputedConstantsArrayMethodString", &libcellml::GeneratorProfile::interfaceCreateComputedConstantsArrayMethodString) + .function("setInterfaceCreateComputedConstantsArrayMethodString", &libcellml::GeneratorProfile::setInterfaceCreateComputedConstantsArrayMethodString) + .function("implementationCreateComputedConstantsArrayMethodString", &libcellml::GeneratorProfile::implementationCreateComputedConstantsArrayMethodString) + .function("setImplementationCreateComputedConstantsArrayMethodString", &libcellml::GeneratorProfile::setImplementationCreateComputedConstantsArrayMethodString) + .function("interfaceCreateAlgebraicArrayMethodString", &libcellml::GeneratorProfile::interfaceCreateAlgebraicArrayMethodString) + .function("setInterfaceCreateAlgebraicArrayMethodString", &libcellml::GeneratorProfile::setInterfaceCreateAlgebraicArrayMethodString) + .function("implementationCreateAlgebraicArrayMethodString", &libcellml::GeneratorProfile::implementationCreateAlgebraicArrayMethodString) + .function("setImplementationCreateAlgebraicArrayMethodString", &libcellml::GeneratorProfile::setImplementationCreateAlgebraicArrayMethodString) + .function("interfaceCreateExternalsArrayMethodString", &libcellml::GeneratorProfile::interfaceCreateExternalsArrayMethodString) + .function("setInterfaceCreateExternalsArrayMethodString", &libcellml::GeneratorProfile::setInterfaceCreateExternalsArrayMethodString) + .function("implementationCreateExternalsArrayMethodString", &libcellml::GeneratorProfile::implementationCreateExternalsArrayMethodString) + .function("setImplementationCreateExternalsArrayMethodString", &libcellml::GeneratorProfile::setImplementationCreateExternalsArrayMethodString) .function("interfaceDeleteArrayMethodString", &libcellml::GeneratorProfile::interfaceDeleteArrayMethodString) .function("setInterfaceDeleteArrayMethodString", &libcellml::GeneratorProfile::setInterfaceDeleteArrayMethodString) .function("implementationDeleteArrayMethodString", &libcellml::GeneratorProfile::implementationDeleteArrayMethodString) diff --git a/src/generator.cpp b/src/generator.cpp index cf994f3e8..d47bdf7ce 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -648,12 +648,26 @@ void Generator::GeneratorImpl::addInterfaceCreateDeleteArrayMethodsCode() code += mProfile->interfaceCreateStatesArrayMethodString(); } - if (!mProfile->interfaceCreateVariablesArrayMethodString().empty()) { - code += mProfile->interfaceCreateVariablesArrayMethodString(); + if (!mProfile->interfaceCreateConstantsArrayMethodString().empty()) { + code += mProfile->interfaceCreateConstantsArrayMethodString(); + } + + if (!mProfile->interfaceCreateComputedConstantsArrayMethodString().empty()) { + code += mProfile->interfaceCreateComputedConstantsArrayMethodString(); + } + + if (!mProfile->interfaceCreateAlgebraicArrayMethodString().empty()) { + code += mProfile->interfaceCreateAlgebraicArrayMethodString(); + } + + if (mModel->hasExternalVariables() + && !mProfile->interfaceCreateExternalsArrayMethodString().empty()) { + code += mProfile->interfaceCreateExternalsArrayMethodString(); } if (!mProfile->interfaceDeleteArrayMethodString().empty()) { - code += mProfile->interfaceDeleteArrayMethodString(); + code += "\n" + + mProfile->interfaceDeleteArrayMethodString(); } if (!code.empty()) { @@ -663,43 +677,53 @@ void Generator::GeneratorImpl::addInterfaceCreateDeleteArrayMethodsCode() mCode += code; } -void Generator::GeneratorImpl::addExternalVariableMethodTypeDefinitionCode() -{ - if (mModel->hasExternalVariables()) { - auto externalVariableMethodTypeDefinitionString = mProfile->externalVariableMethodTypeDefinitionString(modelHasOdes()); - - if (!externalVariableMethodTypeDefinitionString.empty()) { - mCode += "\n" - + externalVariableMethodTypeDefinitionString; - } - } -} - -void Generator::GeneratorImpl::addImplementationCreateStatesArrayMethodCode() +void Generator::GeneratorImpl::addImplementationCreateDeleteArrayMethodsCode() { if (modelHasOdes() && !mProfile->implementationCreateStatesArrayMethodString().empty()) { mCode += newLineIfNeeded() + mProfile->implementationCreateStatesArrayMethodString(); } -} -void Generator::GeneratorImpl::addImplementationCreateVariablesArrayMethodCode() -{ - if (!mProfile->implementationCreateVariablesArrayMethodString().empty()) { + if (!mProfile->implementationCreateConstantsArrayMethodString().empty()) { mCode += newLineIfNeeded() - + mProfile->implementationCreateVariablesArrayMethodString(); + + mProfile->implementationCreateConstantsArrayMethodString(); + } + + if (!mProfile->implementationCreateComputedConstantsArrayMethodString().empty()) { + mCode += newLineIfNeeded() + + mProfile->implementationCreateComputedConstantsArrayMethodString(); + } + + if (!mProfile->implementationCreateAlgebraicArrayMethodString().empty()) { + mCode += newLineIfNeeded() + + mProfile->implementationCreateAlgebraicArrayMethodString(); + } + + if (mModel->hasExternalVariables() + && !mProfile->implementationCreateExternalsArrayMethodString().empty()) { + mCode += newLineIfNeeded() + + mProfile->implementationCreateExternalsArrayMethodString(); } -} -void Generator::GeneratorImpl::addImplementationDeleteArrayMethodCode() -{ if (!mProfile->implementationDeleteArrayMethodString().empty()) { mCode += newLineIfNeeded() + mProfile->implementationDeleteArrayMethodString(); } } +void Generator::GeneratorImpl::addExternalVariableMethodTypeDefinitionCode() +{ + if (mModel->hasExternalVariables()) { + auto externalVariableMethodTypeDefinitionString = mProfile->externalVariableMethodTypeDefinitionString(modelHasOdes()); + + if (!externalVariableMethodTypeDefinitionString.empty()) { + mCode += "\n" + + externalVariableMethodTypeDefinitionString; + } + } +} + void Generator::GeneratorImpl::addRootFindingInfoObjectCode() { if (modelHasNlas() @@ -2066,9 +2090,7 @@ std::string Generator::implementationCode() const // Add code for the implementation to create and delete arrays. - mPimpl->addImplementationCreateStatesArrayMethodCode(); - mPimpl->addImplementationCreateVariablesArrayMethodCode(); - mPimpl->addImplementationDeleteArrayMethodCode(); + mPimpl->addImplementationCreateDeleteArrayMethodsCode(); // Add code for the NLA solver. diff --git a/src/generator_p.h b/src/generator_p.h index 02c6fdf5a..05c3298a6 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -100,10 +100,9 @@ struct Generator::GeneratorImpl void addTrigonometricFunctionsCode(); void addInterfaceCreateDeleteArrayMethodsCode(); + void addImplementationCreateDeleteArrayMethodsCode(); + void addExternalVariableMethodTypeDefinitionCode(); - void addImplementationCreateStatesArrayMethodCode(); - void addImplementationCreateVariablesArrayMethodCode(); - void addImplementationDeleteArrayMethodCode(); void addRootFindingInfoObjectCode(); void addExternNlaSolveMethodCode(); diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 2655cce43..bf01698d5 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -354,12 +354,48 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " return res;\n" "}\n"; - mInterfaceCreateVariablesArrayMethodString = "double * createVariablesArray();\n"; - mImplementationCreateVariablesArrayMethodString = "double * createVariablesArray()\n" + mInterfaceCreateConstantsArrayMethodString = "double * createConstantsArray();\n"; + mImplementationCreateConstantsArrayMethodString = "double * createConstantsArray()\n" "{\n" - " double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double));\n" + " double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double));\n" "\n" - " for (size_t i = 0; i < VARIABLE_COUNT; ++i) {\n" + " for (size_t i = 0; i < CONSTANT_COUNT; ++i) {\n" + " res[i] = NAN;\n" + " }\n" + "\n" + " return res;\n" + "}\n"; + + mInterfaceCreateComputedConstantsArrayMethodString = "double * createComputedConstantsArray();\n"; + mImplementationCreateComputedConstantsArrayMethodString = "double * createComputedConstantsArray()\n" + "{\n" + " double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double));\n" + "\n" + " for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) {\n" + " res[i] = NAN;\n" + " }\n" + "\n" + " return res;\n" + "}\n"; + + mInterfaceCreateAlgebraicArrayMethodString = "double * createAlgebraicArray();\n"; + mImplementationCreateAlgebraicArrayMethodString = "double * createAlgebraicArray()\n" + "{\n" + " double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double));\n" + "\n" + " for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) {\n" + " res[i] = NAN;\n" + " }\n" + "\n" + " return res;\n" + "}\n"; + + mInterfaceCreateExternalsArrayMethodString = "double * createExternalsArray();\n"; + mImplementationCreateExternalsArrayMethodString = "double * createExternalsArray()\n" + "{\n" + " double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double));\n" + "\n" + " for (size_t i = 0; i < EXTERNAL_COUNT; ++i) {\n" " res[i] = NAN;\n" " }\n" "\n" @@ -749,10 +785,25 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "def create_states_array():\n" " return [nan]*STATE_COUNT\n"; - mInterfaceCreateVariablesArrayMethodString = ""; - mImplementationCreateVariablesArrayMethodString = "\n" - "def create_variables_array():\n" - " return [nan]*VARIABLE_COUNT\n"; + mInterfaceCreateConstantsArrayMethodString = ""; + mImplementationCreateConstantsArrayMethodString = "\n" + "def create_constants_array():\n" + " return [nan]*CONSTANT_COUNT\n"; + + mInterfaceCreateComputedConstantsArrayMethodString = ""; + mImplementationCreateComputedConstantsArrayMethodString = "\n" + "def create_computed_constants_array():\n" + " return [nan]*COMPUTED_CONSTANT_COUNT\n"; + + mInterfaceCreateAlgebraicArrayMethodString = ""; + mImplementationCreateAlgebraicArrayMethodString = "\n" + "def create_algebraic_array():\n" + " return [nan]*ALGEBRAIC_COUNT\n"; + + mInterfaceCreateExternalsArrayMethodString = ""; + mImplementationCreateExternalsArrayMethodString = "\n" + "def create_externals_array():\n" + " return [nan]*EXTERNAL_COUNT\n"; mInterfaceDeleteArrayMethodString = ""; mImplementationDeleteArrayMethodString = ""; @@ -2418,24 +2469,84 @@ void GeneratorProfile::setImplementationCreateStatesArrayMethodString(const std: mPimpl->mImplementationCreateStatesArrayMethodString = implementationCreateStatesArrayMethodString; } -std::string GeneratorProfile::interfaceCreateVariablesArrayMethodString() const +std::string GeneratorProfile::interfaceCreateConstantsArrayMethodString() const +{ + return mPimpl->mInterfaceCreateConstantsArrayMethodString; +} + +void GeneratorProfile::setInterfaceCreateConstantsArrayMethodString(const std::string &interfaceCreateConstantsArrayMethodString) +{ + mPimpl->mInterfaceCreateConstantsArrayMethodString = interfaceCreateConstantsArrayMethodString; +} + +std::string GeneratorProfile::implementationCreateConstantsArrayMethodString() const +{ + return mPimpl->mImplementationCreateConstantsArrayMethodString; +} + +void GeneratorProfile::setImplementationCreateConstantsArrayMethodString(const std::string &implementationCreateConstantsArrayMethodString) +{ + mPimpl->mImplementationCreateConstantsArrayMethodString = implementationCreateConstantsArrayMethodString; +} + +std::string GeneratorProfile::interfaceCreateComputedConstantsArrayMethodString() const +{ + return mPimpl->mInterfaceCreateComputedConstantsArrayMethodString; +} + +void GeneratorProfile::setInterfaceCreateComputedConstantsArrayMethodString(const std::string &interfaceCreateComputedConstantsArrayMethodString) +{ + mPimpl->mInterfaceCreateComputedConstantsArrayMethodString = interfaceCreateComputedConstantsArrayMethodString; +} + +std::string GeneratorProfile::implementationCreateComputedConstantsArrayMethodString() const +{ + return mPimpl->mImplementationCreateComputedConstantsArrayMethodString; +} + +void GeneratorProfile::setImplementationCreateComputedConstantsArrayMethodString(const std::string &implementationCreateComputedConstantsArrayMethodString) +{ + mPimpl->mImplementationCreateComputedConstantsArrayMethodString = implementationCreateComputedConstantsArrayMethodString; +} + +std::string GeneratorProfile::interfaceCreateAlgebraicArrayMethodString() const +{ + return mPimpl->mInterfaceCreateAlgebraicArrayMethodString; +} + +void GeneratorProfile::setInterfaceCreateAlgebraicArrayMethodString(const std::string &interfaceCreateAlgebraicArrayMethodString) +{ + mPimpl->mInterfaceCreateAlgebraicArrayMethodString = interfaceCreateAlgebraicArrayMethodString; +} + +std::string GeneratorProfile::implementationCreateAlgebraicArrayMethodString() const +{ + return mPimpl->mImplementationCreateAlgebraicArrayMethodString; +} + +void GeneratorProfile::setImplementationCreateAlgebraicArrayMethodString(const std::string &implementationCreateAlgebraicArrayMethodString) +{ + mPimpl->mImplementationCreateAlgebraicArrayMethodString = implementationCreateAlgebraicArrayMethodString; +} + +std::string GeneratorProfile::interfaceCreateExternalsArrayMethodString() const { - return mPimpl->mInterfaceCreateVariablesArrayMethodString; + return mPimpl->mInterfaceCreateExternalsArrayMethodString; } -void GeneratorProfile::setInterfaceCreateVariablesArrayMethodString(const std::string &interfaceCreateVariablesArrayMethodString) +void GeneratorProfile::setInterfaceCreateExternalsArrayMethodString(const std::string &interfaceCreateExternalsArrayMethodString) { - mPimpl->mInterfaceCreateVariablesArrayMethodString = interfaceCreateVariablesArrayMethodString; + mPimpl->mInterfaceCreateExternalsArrayMethodString = interfaceCreateExternalsArrayMethodString; } -std::string GeneratorProfile::implementationCreateVariablesArrayMethodString() const +std::string GeneratorProfile::implementationCreateExternalsArrayMethodString() const { - return mPimpl->mImplementationCreateVariablesArrayMethodString; + return mPimpl->mImplementationCreateExternalsArrayMethodString; } -void GeneratorProfile::setImplementationCreateVariablesArrayMethodString(const std::string &implementationCreateVariablesArrayMethodString) +void GeneratorProfile::setImplementationCreateExternalsArrayMethodString(const std::string &implementationCreateExternalsArrayMethodString) { - mPimpl->mImplementationCreateVariablesArrayMethodString = implementationCreateVariablesArrayMethodString; + mPimpl->mImplementationCreateExternalsArrayMethodString = implementationCreateExternalsArrayMethodString; } std::string GeneratorProfile::interfaceDeleteArrayMethodString() const diff --git a/src/generatorprofile_p.h b/src/generatorprofile_p.h index e87a24da7..286edca8e 100644 --- a/src/generatorprofile_p.h +++ b/src/generatorprofile_p.h @@ -241,8 +241,17 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mInterfaceCreateStatesArrayMethodString; std::string mImplementationCreateStatesArrayMethodString; - std::string mInterfaceCreateVariablesArrayMethodString; - std::string mImplementationCreateVariablesArrayMethodString; + std::string mInterfaceCreateConstantsArrayMethodString; + std::string mImplementationCreateConstantsArrayMethodString; + + std::string mInterfaceCreateComputedConstantsArrayMethodString; + std::string mImplementationCreateComputedConstantsArrayMethodString; + + std::string mInterfaceCreateAlgebraicArrayMethodString; + std::string mImplementationCreateAlgebraicArrayMethodString; + + std::string mInterfaceCreateExternalsArrayMethodString; + std::string mImplementationCreateExternalsArrayMethodString; std::string mInterfaceDeleteArrayMethodString; std::string mImplementationDeleteArrayMethodString; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 577df6a27..6c33678d7 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "14c2693a5338e70419f230e375f49acef40a68ce"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "23ed0dcff0e9015280889861f4d75420fd14c211"; +static const char C_GENERATOR_PROFILE_SHA1[] = "4b3052f697b7b57e1ffeb50a6a43d332e87fad35"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "17d32a31120c2c7ce57a85e08402419e1509e330"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index 9891778ce..d74e462be 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -507,8 +507,17 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->interfaceCreateStatesArrayMethodString() + generatorProfile->implementationCreateStatesArrayMethodString(); - profileContents += generatorProfile->interfaceCreateVariablesArrayMethodString() - + generatorProfile->implementationCreateVariablesArrayMethodString(); + profileContents += generatorProfile->interfaceCreateConstantsArrayMethodString() + + generatorProfile->implementationCreateConstantsArrayMethodString(); + + profileContents += generatorProfile->interfaceCreateComputedConstantsArrayMethodString() + + generatorProfile->implementationCreateComputedConstantsArrayMethodString(); + + profileContents += generatorProfile->interfaceCreateAlgebraicArrayMethodString() + + generatorProfile->implementationCreateAlgebraicArrayMethodString(); + + profileContents += generatorProfile->interfaceCreateExternalsArrayMethodString() + + generatorProfile->implementationCreateExternalsArrayMethodString(); profileContents += generatorProfile->interfaceDeleteArrayMethodString() + generatorProfile->implementationDeleteArrayMethodString(); diff --git a/tests/bindings/javascript/generator.test.js b/tests/bindings/javascript/generator.test.js index 112ca913e..b5860fd01 100644 --- a/tests/bindings/javascript/generator.test.js +++ b/tests/bindings/javascript/generator.test.js @@ -62,10 +62,10 @@ describe("Generator tests", () => { g.setModel(a.model()) const interface_lines = g.interfaceCode().split('\n') - expect(interface_lines.length).toBe(44) + expect(interface_lines.length).toBe(37) const implementation_lines = g.implementationCode().split('\n') - expect(implementation_lines.length).toBe(66) + expect(implementation_lines.length).toBe(97) const equation_line_1 = libcellml.Generator.equationCode(a.model().equation(0).ast()) expect(equation_line_1.length).toBe(14) diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index 6aa7460ee..81b1b13ff 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -945,17 +945,53 @@ describe("GeneratorProfile tests", () => { x.setImplementationCreateStatesArrayMethodString("something") expect(x.implementationCreateStatesArrayMethodString()).toBe("something") }); - test("Checking GeneratorProfile.interfaceCreateVariablesArrayMethodString.", () => { + test("Checking GeneratorProfile.interfaceCreateConstantsArrayMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceCreateVariablesArrayMethodString("something") - expect(x.interfaceCreateVariablesArrayMethodString()).toBe("something") + x.setInterfaceCreateConstantsArrayMethodString("something") + expect(x.interfaceCreateConstantsArrayMethodString()).toBe("something") }); - test("Checking GeneratorProfile.implementationCreateVariablesArrayMethodString.", () => { + test("Checking GeneratorProfile.implementationCreateConstantsArrayMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationCreateVariablesArrayMethodString("something") - expect(x.implementationCreateVariablesArrayMethodString()).toBe("something") + x.setImplementationCreateConstantsArrayMethodString("something") + expect(x.implementationCreateConstantsArrayMethodString()).toBe("something") + }); + test("Checking GeneratorProfile.interfaceCreateComputedConstantsArrayMethodString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setInterfaceCreateComputedConstantsArrayMethodString("something") + expect(x.interfaceCreateComputedConstantsArrayMethodString()).toBe("something") + }); + test("Checking GeneratorProfile.implementationCreateComputedConstantsArrayMethodString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setImplementationCreateComputedConstantsArrayMethodString("something") + expect(x.implementationCreateComputedConstantsArrayMethodString()).toBe("something") + }); + test("Checking GeneratorProfile.interfaceCreateAlgebraicArrayMethodString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setInterfaceCreateAlgebraicArrayMethodString("something") + expect(x.interfaceCreateAlgebraicArrayMethodString()).toBe("something") + }); + test("Checking GeneratorProfile.implementationCreateAlgebraicArrayMethodString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setImplementationCreateAlgebraicArrayMethodString("something") + expect(x.implementationCreateAlgebraicArrayMethodString()).toBe("something") + }); + test("Checking GeneratorProfile.interfaceCreateExternalsArrayMethodString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setInterfaceCreateExternalsArrayMethodString("something") + expect(x.interfaceCreateExternalsArrayMethodString()).toBe("something") + }); + test("Checking GeneratorProfile.implementationCreateExternalsArrayMethodString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setImplementationCreateExternalsArrayMethodString("something") + expect(x.implementationCreateExternalsArrayMethodString()).toBe("something") }); test("Checking GeneratorProfile.interfaceDeleteArrayMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index cf532b8a6..d4dfabfa5 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -769,16 +769,49 @@ def test_implementation_create_states_array_method_string(self): g.setImplementationCreateStatesArrayMethodString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationCreateStatesArrayMethodString()) - def test_implementation_create_variables_array_method_string(self): + def test_implementation_create_constants_array_method_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() self.assertEqual( - 'double * createVariablesArray()\n{\n double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double));\n\n for (size_t i = 0; i < VARIABLE_COUNT; ++i) {\n res[i] = NAN;\n }\n\n return res;\n}\n', - g.implementationCreateVariablesArrayMethodString()) - g.setImplementationCreateVariablesArrayMethodString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationCreateVariablesArrayMethodString()) + 'double * createConstantsArray()\n{\n double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double));\n\n for (size_t i = 0; i < CONSTANT_COUNT; ++i) {\n res[i] = NAN;\n }\n\n return res;\n}\n', + g.implementationCreateConstantsArrayMethodString()) + g.setImplementationCreateConstantsArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationCreateConstantsArrayMethodString()) + + def test_implementation_create_computed_constants_array_method_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual( + 'double * createComputedConstantsArray()\n{\n double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double));\n\n for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) {\n res[i] = NAN;\n }\n\n return res;\n}\n', + g.implementationCreateComputedConstantsArrayMethodString()) + g.setImplementationCreateComputedConstantsArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationCreateComputedConstantsArrayMethodString()) + + def test_implementation_create_algebraic_array_method_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual( + 'double * createAlgebraicArray()\n{\n double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double));\n\n for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) {\n res[i] = NAN;\n }\n\n return res;\n}\n', + g.implementationCreateAlgebraicArrayMethodString()) + g.setImplementationCreateAlgebraicArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationCreateAlgebraicArrayMethodString()) + + def test_implementation_create_externals_array_method_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual( + 'double * createExternalsArray()\n{\n double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double));\n\n for (size_t i = 0; i < EXTERNAL_COUNT; ++i) {\n res[i] = NAN;\n }\n\n return res;\n}\n', + g.implementationCreateExternalsArrayMethodString()) + g.setImplementationCreateExternalsArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationCreateExternalsArrayMethodString()) def test_implementation_delete_array_method_string(self): from libcellml import GeneratorProfile @@ -1026,14 +1059,41 @@ def test_interface_create_states_array_method_string(self): g.setInterfaceCreateStatesArrayMethodString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceCreateStatesArrayMethodString()) - def test_interface_create_variables_array_method_string(self): + def test_interface_create_constants_array_method_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('double * createConstantsArray();\n', g.interfaceCreateConstantsArrayMethodString()) + g.setInterfaceCreateConstantsArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceCreateConstantsArrayMethodString()) + + def test_interface_create_computed_constants_array_method_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('double * createComputedConstantsArray();\n', g.interfaceCreateComputedConstantsArrayMethodString()) + g.setInterfaceCreateComputedConstantsArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceCreateComputedConstantsArrayMethodString()) + + def test_interface_create_algebraic_array_method_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('double * createAlgebraicArray();\n', g.interfaceCreateAlgebraicArrayMethodString()) + g.setInterfaceCreateAlgebraicArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceCreateAlgebraicArrayMethodString()) + + def test_interface_create_externals_array_method_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('double * createVariablesArray();\n', g.interfaceCreateVariablesArrayMethodString()) - g.setInterfaceCreateVariablesArrayMethodString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceCreateVariablesArrayMethodString()) + self.assertEqual('double * createExternalsArray();\n', g.interfaceCreateExternalsArrayMethodString()) + g.setInterfaceCreateExternalsArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceCreateExternalsArrayMethodString()) def test_interface_delete_array_method_string(self): from libcellml import GeneratorProfile diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index b2e37fbab..097dcdacc 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -736,7 +736,13 @@ TEST(Coverage, generator) profile->setImplementationCreateStatesArrayMethodString(""); - profile->setImplementationCreateVariablesArrayMethodString(""); + profile->setImplementationCreateConstantsArrayMethodString(""); + + profile->setImplementationCreateComputedConstantsArrayMethodString(""); + + profile->setImplementationCreateAlgebraicArrayMethodString(""); + + profile->setImplementationCreateExternalsArrayMethodString(""); profile->setImplementationDeleteArrayMethodString(""); diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 97cba4127..cf556ec3f 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -347,20 +347,6 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("externalVariable(variables, [INDEX])", generatorProfile->externalVariableMethodCallString(false)); EXPECT_EQ("externalVariable(voi, states, rates, variables, [INDEX])", generatorProfile->externalVariableMethodCallString(true)); - EXPECT_EQ("double * createStatesArray();\n", - generatorProfile->interfaceCreateStatesArrayMethodString()); - EXPECT_EQ("double * createStatesArray()\n" - "{\n" - " double *res = (double *) malloc(STATE_COUNT*sizeof(double));\n" - "\n" - " for (size_t i = 0; i < STATE_COUNT; ++i) {\n" - " res[i] = NAN;\n" - " }\n" - "\n" - " return res;\n" - "}\n", - generatorProfile->implementationCreateStatesArrayMethodString()); - EXPECT_EQ("typedef struct {\n" " double *variables;\n" "} RootFindingInfo;\n", @@ -421,19 +407,75 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("f", generatorProfile->fArrayString()); - EXPECT_EQ("double * createVariablesArray();\n", - generatorProfile->interfaceCreateVariablesArrayMethodString()); - EXPECT_EQ("double * createVariablesArray()\n" + EXPECT_EQ("double * createStatesArray();\n", + generatorProfile->interfaceCreateStatesArrayMethodString()); + EXPECT_EQ("double * createStatesArray()\n" + "{\n" + " double *res = (double *) malloc(STATE_COUNT*sizeof(double));\n" + "\n" + " for (size_t i = 0; i < STATE_COUNT; ++i) {\n" + " res[i] = NAN;\n" + " }\n" + "\n" + " return res;\n" + "}\n", + generatorProfile->implementationCreateStatesArrayMethodString()); + + EXPECT_EQ("double * createConstantsArray();\n", + generatorProfile->interfaceCreateConstantsArrayMethodString()); + EXPECT_EQ("double * createConstantsArray()\n" + "{\n" + " double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double));\n" + "\n" + " for (size_t i = 0; i < CONSTANT_COUNT; ++i) {\n" + " res[i] = NAN;\n" + " }\n" + "\n" + " return res;\n" + "}\n", + generatorProfile->implementationCreateConstantsArrayMethodString()); + + EXPECT_EQ("double * createComputedConstantsArray();\n", + generatorProfile->interfaceCreateComputedConstantsArrayMethodString()); + EXPECT_EQ("double * createComputedConstantsArray()\n" + "{\n" + " double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double));\n" + "\n" + " for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) {\n" + " res[i] = NAN;\n" + " }\n" + "\n" + " return res;\n" + "}\n", + generatorProfile->implementationCreateComputedConstantsArrayMethodString()); + + EXPECT_EQ("double * createAlgebraicArray();\n", + generatorProfile->interfaceCreateAlgebraicArrayMethodString()); + EXPECT_EQ("double * createAlgebraicArray()\n" "{\n" - " double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double));\n" + " double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double));\n" "\n" - " for (size_t i = 0; i < VARIABLE_COUNT; ++i) {\n" + " for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) {\n" " res[i] = NAN;\n" " }\n" "\n" " return res;\n" "}\n", - generatorProfile->implementationCreateVariablesArrayMethodString()); + generatorProfile->implementationCreateAlgebraicArrayMethodString()); + + EXPECT_EQ("double * createExternalsArray();\n", + generatorProfile->interfaceCreateExternalsArrayMethodString()); + EXPECT_EQ("double * createExternalsArray()\n" + "{\n" + " double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double));\n" + "\n" + " for (size_t i = 0; i < EXTERNAL_COUNT; ++i) {\n" + " res[i] = NAN;\n" + " }\n" + "\n" + " return res;\n" + "}\n", + generatorProfile->implementationCreateExternalsArrayMethodString()); EXPECT_EQ("void deleteArray(double *array);\n", generatorProfile->interfaceDeleteArrayMethodString()); @@ -903,9 +945,6 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setExternalVariableMethodCallString(false, value); generatorProfile->setExternalVariableMethodCallString(true, value); - generatorProfile->setInterfaceCreateStatesArrayMethodString(value); - generatorProfile->setImplementationCreateStatesArrayMethodString(value); - generatorProfile->setRootFindingInfoObjectString(false, value); generatorProfile->setRootFindingInfoObjectString(true, value); generatorProfile->setExternNlaSolveMethodString(value); @@ -920,8 +959,20 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setUArrayString(value); generatorProfile->setFArrayString(value); - generatorProfile->setInterfaceCreateVariablesArrayMethodString(value); - generatorProfile->setImplementationCreateVariablesArrayMethodString(value); + generatorProfile->setInterfaceCreateStatesArrayMethodString(value); + generatorProfile->setImplementationCreateStatesArrayMethodString(value); + + generatorProfile->setInterfaceCreateConstantsArrayMethodString(value); + generatorProfile->setImplementationCreateConstantsArrayMethodString(value); + + generatorProfile->setInterfaceCreateComputedConstantsArrayMethodString(value); + generatorProfile->setImplementationCreateComputedConstantsArrayMethodString(value); + + generatorProfile->setInterfaceCreateAlgebraicArrayMethodString(value); + generatorProfile->setImplementationCreateAlgebraicArrayMethodString(value); + + generatorProfile->setInterfaceCreateExternalsArrayMethodString(value); + generatorProfile->setImplementationCreateExternalsArrayMethodString(value); generatorProfile->setInterfaceDeleteArrayMethodString(value); generatorProfile->setImplementationDeleteArrayMethodString(value); @@ -1040,9 +1091,6 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->externalVariableMethodCallString(false)); EXPECT_EQ(value, generatorProfile->externalVariableMethodCallString(true)); - EXPECT_EQ(value, generatorProfile->interfaceCreateStatesArrayMethodString()); - EXPECT_EQ(value, generatorProfile->implementationCreateStatesArrayMethodString()); - EXPECT_EQ(value, generatorProfile->rootFindingInfoObjectString(false)); EXPECT_EQ(value, generatorProfile->rootFindingInfoObjectString(true)); EXPECT_EQ(value, generatorProfile->externNlaSolveMethodString()); @@ -1057,8 +1105,20 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->uArrayString()); EXPECT_EQ(value, generatorProfile->fArrayString()); - EXPECT_EQ(value, generatorProfile->interfaceCreateVariablesArrayMethodString()); - EXPECT_EQ(value, generatorProfile->implementationCreateVariablesArrayMethodString()); + EXPECT_EQ(value, generatorProfile->interfaceCreateStatesArrayMethodString()); + EXPECT_EQ(value, generatorProfile->implementationCreateStatesArrayMethodString()); + + EXPECT_EQ(value, generatorProfile->interfaceCreateConstantsArrayMethodString()); + EXPECT_EQ(value, generatorProfile->implementationCreateConstantsArrayMethodString()); + + EXPECT_EQ(value, generatorProfile->interfaceCreateComputedConstantsArrayMethodString()); + EXPECT_EQ(value, generatorProfile->implementationCreateComputedConstantsArrayMethodString()); + + EXPECT_EQ(value, generatorProfile->interfaceCreateAlgebraicArrayMethodString()); + EXPECT_EQ(value, generatorProfile->implementationCreateAlgebraicArrayMethodString()); + + EXPECT_EQ(value, generatorProfile->interfaceCreateExternalsArrayMethodString()); + EXPECT_EQ(value, generatorProfile->implementationCreateExternalsArrayMethodString()); EXPECT_EQ(value, generatorProfile->interfaceDeleteArrayMethodString()); EXPECT_EQ(value, generatorProfile->implementationDeleteArrayMethodString()); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index e65de4ae9..ada5039d4 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -329,11 +329,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index f394f9503..8b62b74a8 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 03233d917..9201225b7 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -92,11 +92,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index ecc8522e2..e461b70ad 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -5,7 +5,10 @@ #include double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index d63bb27d2..a31b1d6fb 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -329,11 +329,33 @@ double * createStatesVector() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index fb41e8e19..ead7dbbbd 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesVector(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 450b76136..91b686c18 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -342,8 +342,16 @@ def create_states_vector(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT from nlasolver import nla_solve diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 0ddd0fe1e..11f1633e8 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -342,8 +342,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT from nlasolver import nla_solve diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index d3373bd80..8fe7fe5af 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -23,11 +23,33 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { const VariableInfo ALGEBRAIC_INFO[] = { }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index fcac8daa3..726d2e4df 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -27,11 +27,44 @@ const VariableInfo EXTERNAL_INFO[] = { {"a", "dimensionless", "my_algebraic_eqn"} }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index ae517dbae..f2e5f8bea 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -23,7 +23,11 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 5aad8e932..85f1fc1c3 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -27,8 +27,20 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(constants, external_variable): diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index e7483121b..09bd540e1 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -21,7 +21,10 @@ extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *constants); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index 5b2757c65..ccb33cdae 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -23,8 +23,16 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(constants): diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index f1a027bb9..4fec075e2 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -23,11 +23,33 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { const VariableInfo ALGEBRAIC_INFO[] = { }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index e7483121b..09bd540e1 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -21,7 +21,10 @@ extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *constants); diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index 11f3c989c..44cf1813a 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -23,8 +23,16 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(constants): diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index d675f0bf5..496cd753d 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -22,11 +22,33 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { const VariableInfo ALGEBRAIC_INFO[] = { }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index c22b33894..9b095efd7 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -21,7 +21,10 @@ extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *constants); diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index 32441f8f5..09de22b37 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -22,8 +22,16 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(constants): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index b74b04c00..50204c636 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -41,11 +41,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index 897ad01fb..8f773b690 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 50a4280dd..24dc85a5d 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -33,8 +33,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index b5dfae272..4350ef5f0 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -41,11 +41,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index 1c36d8d5f..83c078386 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 03b8c76bc..710d4a6bd 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -33,8 +33,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 5d8fd74b9..3f88fde85 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -41,11 +41,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index 5d58dcfbb..8fb87aae1 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 20c3b7247..0527bf97d 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -33,8 +33,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 9312cbe36..bff87c275 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -41,11 +41,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index de15f76cf..c473a17f5 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index b20a4ecff..c17f55153 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -33,8 +33,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index c03fdb714..7cad55350 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -25,11 +25,33 @@ const VariableInfo ALGEBRAIC_INFO[] = { {"a", "dimensionless", "my_algebraic_eqn"} }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index dfeff7ef9..bfb49ec7c 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -29,11 +29,44 @@ const VariableInfo EXTERNAL_INFO[] = { {"a", "dimensionless", "my_algebraic_eqn"} }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index ae517dbae..f2e5f8bea 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -23,7 +23,11 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index c63f98fa9..c50b81426 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -29,8 +29,20 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(constants, external_variable): diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index e7483121b..09bd540e1 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -21,7 +21,10 @@ extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *constants); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index ac5049aa0..36471b519 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -25,8 +25,16 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT from nlasolver import nla_solve diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index 650710a25..8c0c46b90 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -24,11 +24,33 @@ const VariableInfo ALGEBRAIC_INFO[] = { {"z", "dimensionless", "my_algebraic_system"} }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index a8b4dbbcc..9c4390a45 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -21,7 +21,10 @@ extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *constants); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 00c16f398..5152bedc3 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -24,8 +24,16 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT from nlasolver import nla_solve diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index d2d15bfa5..f4891c4a7 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -28,11 +28,44 @@ const VariableInfo EXTERNAL_INFO[] = { {"z", "dimensionless", "my_algebraic_system"} }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index 7e21388ca..4a61d58c7 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -23,7 +23,11 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index bc87f9344..c48580961 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -28,8 +28,20 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(constants, external_variable): diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index feb3430ed..6ec8b1670 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -27,11 +27,33 @@ const VariableInfo ALGEBRAIC_INFO[] = { {"c", "dimensionless", "my_algebraic_system"} }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index a8b4dbbcc..9c4390a45 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -21,7 +21,10 @@ extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *constants); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 4c438c3f1..4b3aefa55 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -27,8 +27,16 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT from nlasolver import nla_solve diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index 48ed210ad..374b6387c 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -27,11 +27,33 @@ const VariableInfo ALGEBRAIC_INFO[] = { {"d", "dimensionless", "my_algebraic_system"} }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index a8b4dbbcc..9c4390a45 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -21,7 +21,10 @@ extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *constants); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index d58855d92..26d826e4c 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -27,8 +27,16 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT from nlasolver import nla_solve diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index 8bfb7a585..9aa43b5ee 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -23,11 +23,33 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { const VariableInfo ALGEBRAIC_INFO[] = { }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index c22b33894..9b095efd7 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -21,7 +21,10 @@ extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *constants); diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 0740ee0de..2d8071055 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -23,8 +23,16 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(constants): diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index a4bb58334..4fb93ec8e 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -25,11 +25,33 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { const VariableInfo ALGEBRAIC_INFO[] = { }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 7a5964bc5..2cf2258ce 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -29,11 +29,44 @@ const VariableInfo EXTERNAL_INFO[] = { {"rad", "centimeter", "cell_geometry"} }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 36d3e1822..60a5dac8e 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -23,7 +23,11 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index aa3d00363..60c18b4a8 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -29,8 +29,20 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(constants, external_variable): diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index 687403023..adc63ee0d 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -21,7 +21,10 @@ extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *constants); diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index 4ba53cbcc..632242c00 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -25,8 +25,16 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(constants): diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 5bb0dea81..f37a28dea 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -42,11 +42,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index ad9e483ac..d33f9c169 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 21fd05b38..ce2e8a5f3 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -34,8 +34,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index e75683666..9c4aec544 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -31,8 +31,16 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(constants): diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index 074a5a21b..121c73290 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -40,11 +40,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index b05828f9b..b5e1553fd 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 0a0aa2864..8f685b2ab 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -32,8 +32,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index cabb1e728..89d15758a 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -24,11 +24,33 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { const VariableInfo ALGEBRAIC_INFO[] = { }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index 1fff52ad9..57ef15ccd 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -21,7 +21,10 @@ extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *constants); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index 02d595b20..179fc7bf5 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -24,8 +24,16 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(constants): diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index c0529e1dc..cc090e14d 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -41,11 +41,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index b05828f9b..b5e1553fd 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 536b041dd..db91581c9 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -33,8 +33,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index f2664b5fa..7129623ca 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -41,11 +41,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index b05828f9b..b5e1553fd 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index 3a560fa48..efe00b6e4 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -33,8 +33,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index 94efa316a..27254205c 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -40,11 +40,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index b889cfc43..6a5fb1488 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index dce4e92ce..bc5026954 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -32,8 +32,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index 52c79b1c7..c7b46d5af 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -42,11 +42,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 59b9535ec..5ca5788bc 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 98b669a5f..5e1c748cd 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -34,8 +34,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index 63f8794d1..93a512d31 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -40,11 +40,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index 8d446982d..319a116d0 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index b8ff408e5..8ec3b32d4 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -32,8 +32,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index d3b8f3522..c8fa6eabe 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -41,11 +41,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 749c14ce7..52fda2a3b 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index c651290c6..a5d2a5ec0 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -33,8 +33,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 1ebd5e5fb..a21add9d8 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -50,11 +50,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index b6b9e63d2..7a1968fd6 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index ec7692c38..f1bef75dc 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -42,8 +42,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT from nlasolver import nla_solve diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index abaa47ae6..9367b233f 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -41,11 +41,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 31a196c76..006a4093e 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index a2d3b99f8..b60c94ccf 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -33,8 +33,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index a382c211b..40f092eb9 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -288,11 +288,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 72b9004c1..559cb88d6 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 41c323410..e216fc6a4 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -300,8 +300,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index cd6dbc4de..51a8f5289 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -238,11 +238,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 4edb4f720..5aca23091 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index a10fd42ef..8eda5b420 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -238,8 +238,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 8bb552378..27a20813d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -64,11 +64,44 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index 87c9d97a5..e30a552fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -27,7 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 1b9d75ed2..30ad480ea 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -68,8 +68,20 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(voi, states, rates, constants, external_variable): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 77ac9b4be..7a9b63a34 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -60,11 +60,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index b47898024..2f1d436b5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -64,11 +64,44 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index 87c9d97a5..e30a552fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -27,7 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 45f4360d8..a8489aee6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -68,8 +68,20 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(voi, states, rates, constants, external_variable): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 7de8288be..13e2f7517 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -64,11 +64,44 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index 87c9d97a5..e30a552fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -27,7 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 96c8a1f6e..378af0a1b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -68,8 +68,20 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(voi, states, rates, constants, external_variable): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index d15936a8a..543ff0e57 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -60,11 +60,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index d64d07bb6..ea730f343 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 9293f1936..258d847ea 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -64,8 +64,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT from nlasolver import nla_solve diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 070a92f7b..8c59caf7d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -64,11 +64,44 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index 87c9d97a5..e30a552fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -27,7 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index a03e31643..4664272cf 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -68,8 +68,20 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(voi, states, rates, constants, external_variable): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index d34a01efc..327f50b3b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -64,11 +64,44 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index 87c9d97a5..e30a552fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -27,7 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index e655d50b5..70ef952df 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -68,8 +68,20 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(voi, states, rates, constants, external_variable): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index c93e668a0..c8ecad99e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -64,11 +64,44 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index 87c9d97a5..e30a552fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -27,7 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index bdb693b0d..308af3296 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -68,8 +68,20 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(voi, states, rates, constants, external_variable): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index f7bfa5c34..02e6af377 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -64,11 +64,44 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index 87c9d97a5..e30a552fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -27,7 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index ef8be939e..428ac2d5c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -68,8 +68,20 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(voi, states, rates, constants, external_variable): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 6682384a4..cd8f10240 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -64,11 +64,44 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index 87c9d97a5..e30a552fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -27,7 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 7a5b0bf19..f4e5fa7ce 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -68,8 +68,20 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(voi, states, rates, constants, external_variable): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index d64d07bb6..ea730f343 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 161468ab2..a87129a9a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -64,8 +64,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 69ac3783d..c159999cd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -64,11 +64,44 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index 87c9d97a5..e30a552fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -27,7 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 1574fc8fd..1e33ef616 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -68,8 +68,20 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(voi, states, rates, constants, external_variable): diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 42e464392..edde742db 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -59,11 +59,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index a4c01ffa0..c8b91de02 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 0b75dd777..00c9d24e7 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -51,8 +51,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index abf35649d..abdd00879 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -40,11 +40,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index 8d446982d..319a116d0 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 81b6db4c1..775459ff5 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -32,8 +32,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index e6eecbfdc..ca6456d26 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -40,11 +40,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index 1c36d8d5f..83c078386 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 6f9c31e1e..e6a977d94 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -32,8 +32,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index a0af88531..bc63cf66f 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -40,11 +40,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index 8d446982d..319a116d0 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 0bf4f4f64..bb910e5e4 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -32,8 +32,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index 043bda45b..e5fe086ff 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -40,11 +40,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index 1c36d8d5f..83c078386 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index ea5912c7d..6c83ec466 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -32,8 +32,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index 67645bc1c..ef1c80b1d 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -39,11 +39,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index 8d446982d..319a116d0 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index 9147b5ae6..34d1e7d85 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -31,8 +31,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 074534564..796d807b3 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -39,11 +39,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index 1c36d8d5f..83c078386 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index e159a2b5c..bb143cbb1 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -31,8 +31,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 861ca5c1a..f1165a8a1 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -41,11 +41,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index 6b58848d0..f46f3ac1b 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 5daabe1bc..b442e1d9f 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -33,8 +33,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index f4347cdb6..7cfa8679f 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -41,11 +41,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index e4d23b9b6..96b38288f 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 073d05fac..8dccc27dd 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -33,8 +33,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 140486722..17f5507ae 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -41,11 +41,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index 5c800ad65..0f14d5268 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index ebce3e2e6..7d64e5d32 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -33,8 +33,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index a27eb2cf0..69a88e243 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -40,11 +40,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index 8d446982d..319a116d0 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 9e678173d..0e06f1051 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -32,8 +32,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 1c4dbb976..a25eebb91 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -45,11 +45,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index 03322f766..bffe009c7 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 83ae00049..bab387d15 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -37,8 +37,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT from nlasolver import nla_solve diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index ead2f0880..403affc05 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -45,11 +45,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index 03322f766..bffe009c7 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 6fd0e88e1..1faef1ab5 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -37,8 +37,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index d03b04f92..d13cfac71 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -49,11 +49,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index 67daeb345..d6150b9fc 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 73c276d42..98456bf5f 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -45,8 +45,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 7ca1689b4..a99d9f146 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -35,11 +35,44 @@ const VariableInfo EXTERNAL_INFO[] = { {"P_3", "per_fmol_sec3", "SLC_template3_ss"} }; -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 5cbdcf0fb..7ddf98552 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -23,7 +23,11 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; extern const VariableInfo EXTERNAL_INFO[]; -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 6b40d05ec..06195b207 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -35,8 +35,20 @@ ] -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT def initialise_variables(constants, external_variable): diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index f07d91112..0c99f7c24 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -40,11 +40,33 @@ double * createStatesArray() return res; } -double * createVariablesArray() +double * createConstantsArray() { - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { res[i] = NAN; } diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index 401821925..18bcd588e 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -25,7 +25,10 @@ extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); -double * createVariablesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); + void deleteArray(double *array); void initialiseVariables(double *states, double *rates, double *constants); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index c532e1007..e1fdff433 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -32,8 +32,16 @@ def create_states_array(): return [nan]*STATE_COUNT -def create_variables_array(): - return [nan]*VARIABLE_COUNT +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT def initialise_variables(states, rates, constants): From 46e4e939cb64afb77fc908b1d66e0ecd48412e49 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 15 Aug 2024 11:22:58 +0200 Subject: [PATCH 23/74] Generator: updated the signature of our initialiseVariables() method. --- src/generatorprofile.cpp | 24 +++++++++---------- src/generatorprofilesha1values.h | 4 ++-- .../bindings/python/test_generator_profile.py | 16 ++++++------- tests/generator/generatorprofile.cpp | 16 ++++++------- tests/resources/coverage/generator/model.c | 2 +- tests/resources/coverage/generator/model.h | 2 +- .../generator/model.implementation.out | 2 +- .../coverage/generator/model.interface.out | 2 +- .../generator/model.modified.profile.c | 2 +- .../generator/model.modified.profile.h | 2 +- .../generator/model.modified.profile.py | 2 +- tests/resources/coverage/generator/model.out | 2 +- tests/resources/coverage/generator/model.py | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.h | 2 +- .../model.py | 2 +- .../algebraic_eqn_const_var_on_rhs/model.c | 2 +- .../algebraic_eqn_const_var_on_rhs/model.h | 2 +- .../algebraic_eqn_const_var_on_rhs/model.py | 2 +- .../algebraic_eqn_constant_on_rhs/model.c | 2 +- .../algebraic_eqn_constant_on_rhs/model.h | 2 +- .../algebraic_eqn_constant_on_rhs/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs/model.h | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs/model.h | 2 +- .../algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.three.externals.c | 2 +- .../model.three.externals.h | 2 +- .../model.three.externals.py | 2 +- .../model.not.ordered.c | 2 +- .../model.not.ordered.h | 2 +- .../model.not.ordered.py | 2 +- .../model.ordered.c | 2 +- .../model.ordered.h | 2 +- .../model.ordered.py | 2 +- .../algebraic_unknown_var_on_rhs/model.c | 2 +- .../algebraic_unknown_var_on_rhs/model.h | 2 +- .../algebraic_unknown_var_on_rhs/model.py | 2 +- .../generator/cell_geometry_model/model.c | 2 +- .../cell_geometry_model/model.external.c | 2 +- .../cell_geometry_model/model.external.h | 2 +- .../cell_geometry_model/model.external.py | 2 +- .../generator/cell_geometry_model/model.h | 2 +- .../generator/cell_geometry_model/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/cellml_slc_example/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../cellml_unit_scaling_constant/model.c | 2 +- .../cellml_unit_scaling_constant/model.h | 2 +- .../cellml_unit_scaling_constant/model.py | 2 +- .../cellml_unit_scaling_rate/model.c | 2 +- .../cellml_unit_scaling_rate/model.h | 2 +- .../cellml_unit_scaling_rate/model.py | 2 +- .../cellml_unit_scaling_state/model.c | 2 +- .../cellml_unit_scaling_state/model.h | 2 +- .../cellml_unit_scaling_state/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../cellml_unit_scaling_voi_direct/model.c | 2 +- .../cellml_unit_scaling_voi_direct/model.h | 2 +- .../cellml_unit_scaling_voi_direct/model.py | 2 +- .../cellml_unit_scaling_voi_indirect/model.c | 2 +- .../cellml_unit_scaling_voi_indirect/model.h | 2 +- .../cellml_unit_scaling_voi_indirect/model.py | 2 +- .../generator/dae_cellml_1_1_model/model.c | 2 +- .../generator/dae_cellml_1_1_model/model.h | 2 +- .../generator/dae_cellml_1_1_model/model.py | 2 +- .../generator/dependent_eqns/model.c | 2 +- .../generator/dependent_eqns/model.h | 2 +- .../generator/dependent_eqns/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.algebraic.c | 2 +- .../model.algebraic.h | 2 +- .../model.algebraic.py | 2 +- .../model.c | 2 +- .../model.computed.constant.c | 2 +- .../model.computed.constant.h | 2 +- .../model.computed.constant.py | 2 +- .../model.constant.c | 2 +- .../model.constant.h | 2 +- .../model.constant.py | 2 +- .../model.dae.c | 2 +- .../model.dae.h | 2 +- .../model.dae.py | 2 +- .../model.dependent.algebraic.c | 2 +- .../model.dependent.algebraic.h | 2 +- .../model.dependent.algebraic.py | 2 +- .../model.dependent.computed.constant.c | 2 +- .../model.dependent.computed.constant.h | 2 +- .../model.dependent.computed.constant.py | 2 +- .../model.dependent.constant.c | 2 +- .../model.dependent.constant.h | 2 +- .../model.dependent.constant.py | 2 +- .../model.dependent.state.c | 2 +- .../model.dependent.state.h | 2 +- .../model.dependent.state.py | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.state.c | 2 +- .../model.state.h | 2 +- .../model.state.py | 2 +- .../generator/noble_model_1962/model.c | 2 +- .../generator/noble_model_1962/model.h | 2 +- .../generator/noble_model_1962/model.py | 2 +- .../generator/ode_computed_var_on_rhs/model.c | 2 +- .../generator/ode_computed_var_on_rhs/model.h | 2 +- .../ode_computed_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/ode_const_var_on_rhs/model.c | 2 +- .../generator/ode_const_var_on_rhs/model.h | 2 +- .../generator/ode_const_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/ode_constant_on_rhs/model.c | 2 +- .../generator/ode_constant_on_rhs/model.h | 2 +- .../generator/ode_constant_on_rhs/model.py | 2 +- .../ode_constant_on_rhs_one_component/model.c | 2 +- .../ode_constant_on_rhs_one_component/model.h | 2 +- .../model.py | 2 +- .../ode_multiple_dependent_odes/model.c | 2 +- .../ode_multiple_dependent_odes/model.h | 2 +- .../ode_multiple_dependent_odes/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../ode_multiple_odes_with_same_name/model.c | 2 +- .../ode_multiple_odes_with_same_name/model.h | 2 +- .../ode_multiple_odes_with_same_name/model.py | 2 +- .../generator/ode_unknown_var_on_rhs/model.c | 2 +- .../generator/ode_unknown_var_on_rhs/model.h | 2 +- .../generator/ode_unknown_var_on_rhs/model.py | 2 +- .../robertson_model_1966/model.dae.c | 2 +- .../robertson_model_1966/model.dae.h | 2 +- .../robertson_model_1966/model.dae.py | 2 +- .../robertson_model_1966/model.ode.c | 2 +- .../robertson_model_1966/model.ode.h | 2 +- .../robertson_model_1966/model.ode.py | 2 +- .../generator/sine_model_imports/model.c | 2 +- .../generator/sine_model_imports/model.h | 2 +- .../generator/sine_model_imports/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- 185 files changed, 211 insertions(+), 211 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index bf01698d5..18d29dc32 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -408,26 +408,26 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " free(array);\n" "}\n"; - mInterfaceInitialiseVariablesMethodFamWoevString = "void initialiseVariables(double *constants);\n"; - mImplementationInitialiseVariablesMethodFamWoevString = "void initialiseVariables(double *constants)\n" + mInterfaceInitialiseVariablesMethodFamWoevString = "void initialiseVariables(double *constants, double *algebraic);\n"; + mImplementationInitialiseVariablesMethodFamWoevString = "void initialiseVariables(double *constants, double *algebraic)\n" "{\n" "[CODE]" "}\n"; - mInterfaceInitialiseVariablesMethodFamWevString = "void initialiseVariables(double *constants, ExternalVariable externalVariable);\n"; - mImplementationInitialiseVariablesMethodFamWevString = "void initialiseVariables(double *constants, ExternalVariable externalVariable)\n" + mInterfaceInitialiseVariablesMethodFamWevString = "void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable);\n"; + mImplementationInitialiseVariablesMethodFamWevString = "void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n"; - mInterfaceInitialiseVariablesMethodFdmWoevString = "void initialiseVariables(double *states, double *rates, double *constants);\n"; - mImplementationInitialiseVariablesMethodFdmWoevString = "void initialiseVariables(double *states, double *rates, double *constants)\n" + mInterfaceInitialiseVariablesMethodFdmWoevString = "void initialiseVariables(double *states, double *rates, double *constants, double *algebraic);\n"; + mImplementationInitialiseVariablesMethodFdmWoevString = "void initialiseVariables(double *states, double *rates, double *constants, double *algebraic)\n" "{\n" "[CODE]" "}\n"; - mInterfaceInitialiseVariablesMethodFdmWevString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable);\n"; - mImplementationInitialiseVariablesMethodFdmWevString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable)\n" + mInterfaceInitialiseVariablesMethodFdmWevString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable);\n"; + mImplementationInitialiseVariablesMethodFdmWevString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n"; @@ -810,22 +810,22 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceInitialiseVariablesMethodFamWoevString = ""; mImplementationInitialiseVariablesMethodFamWoevString = "\n" - "def initialise_variables(constants):\n" + "def initialise_variables(constants, algebraic):\n" "[CODE]"; mInterfaceInitialiseVariablesMethodFamWevString = ""; mImplementationInitialiseVariablesMethodFamWevString = "\n" - "def initialise_variables(constants, external_variable):\n" + "def initialise_variables(constants, algebraic, external_variable):\n" "[CODE]"; mInterfaceInitialiseVariablesMethodFdmWoevString = ""; mImplementationInitialiseVariablesMethodFdmWoevString = "\n" - "def initialise_variables(states, rates, constants):\n" + "def initialise_variables(states, rates, constants, algebraic):\n" "[CODE]"; mInterfaceInitialiseVariablesMethodFdmWevString = ""; mImplementationInitialiseVariablesMethodFdmWevString = "\n" - "def initialise_variables(voi, states, rates, constants, external_variable):\n" + "def initialise_variables(voi, states, rates, constants, algebraic, external_variable):\n" "[CODE]"; mInterfaceComputeComputedConstantsMethodString = ""; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 6c33678d7..2b8290157 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "4b3052f697b7b57e1ffeb50a6a43d332e87fad35"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "17d32a31120c2c7ce57a85e08402419e1509e330"; +static const char C_GENERATOR_PROFILE_SHA1[] = "2d4d14df0a454d95e32e1172503d529834c42588"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "9f79e69847b6ec2faeb7f56f476ef2542a901b1f"; } // namespace libcellml diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index d4dfabfa5..7c97f547d 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -838,22 +838,22 @@ def test_implementation_initialise_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void initialiseVariables(double *constants)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double *constants, double *algebraic)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(False, False)) g.setImplementationInitialiseVariablesMethodString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(False, False)) - self.assertEqual('void initialiseVariables(double *constants, ExternalVariable externalVariable)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(False, True)) g.setImplementationInitialiseVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(False, True)) - self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *algebraic)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(True, False)) g.setImplementationInitialiseVariablesMethodString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(True, False)) - self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(True, True)) g.setImplementationInitialiseVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(True, True)) @@ -1127,22 +1127,22 @@ def test_interface_initialise_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void initialiseVariables(double *constants);\n', + self.assertEqual('void initialiseVariables(double *constants, double *algebraic);\n', g.interfaceInitialiseVariablesMethodString(False, False)) g.setInterfaceInitialiseVariablesMethodString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(False, False)) - self.assertEqual('void initialiseVariables(double *constants, ExternalVariable externalVariable);\n', + self.assertEqual('void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable);\n', g.interfaceInitialiseVariablesMethodString(False, True)) g.setInterfaceInitialiseVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(False, True)) - self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants);\n', + self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *algebraic);\n', g.interfaceInitialiseVariablesMethodString(True, False)) g.setInterfaceInitialiseVariablesMethodString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(True, False)) - self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable);\n', + self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable);\n', g.interfaceInitialiseVariablesMethodString(True, True)) g.setInterfaceInitialiseVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(True, True)) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index cf556ec3f..1e8b33b53 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -485,33 +485,33 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationDeleteArrayMethodString()); - EXPECT_EQ("void initialiseVariables(double *constants);\n", + EXPECT_EQ("void initialiseVariables(double *constants, double *algebraic);\n", generatorProfile->interfaceInitialiseVariablesMethodString(false, false)); - EXPECT_EQ("void initialiseVariables(double *constants)\n" + EXPECT_EQ("void initialiseVariables(double *constants, double *algebraic)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationInitialiseVariablesMethodString(false, false)); - EXPECT_EQ("void initialiseVariables(double *constants, ExternalVariable externalVariable);\n", + EXPECT_EQ("void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable);\n", generatorProfile->interfaceInitialiseVariablesMethodString(false, true)); - EXPECT_EQ("void initialiseVariables(double *constants, ExternalVariable externalVariable)\n" + EXPECT_EQ("void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationInitialiseVariablesMethodString(false, true)); - EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants);\n", + EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *algebraic);\n", generatorProfile->interfaceInitialiseVariablesMethodString(true, false)); - EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants)\n" + EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *algebraic)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationInitialiseVariablesMethodString(true, false)); - EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable);\n", + EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable);\n", generatorProfile->interfaceInitialiseVariablesMethodString(true, true)); - EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable)\n" + EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index ada5039d4..95cb0e4fb 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -405,7 +405,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; constants[1] = 2.0; diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 8b62b74a8..f41310108 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 9201225b7..1bd2a352f 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -168,7 +168,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; constants[1] = 2.0; diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index e461b70ad..bd773bffa 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -11,7 +11,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index a31b1d6fb..8b95e5994 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -405,7 +405,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; constants[1] = 2.0; diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index ead7dbbbd..482f4f6c3 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 91b686c18..97288e284 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -382,7 +382,7 @@ def find_root_0(voi, states, rates, variables): algebraic[1] = u[1] -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 1.0 constants[1] = 2.0 constants[2] = 3.0 diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index 97c8f0037..087fc8b7b 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -116,7 +116,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; constants[1] = 2.0; diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 11f1633e8..87832d45c 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -382,7 +382,7 @@ def find_root_0(voi, states, rates, variables): algebraic[1] = u[1] -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 1.0 constants[1] = 2.0 constants[2] = 3.0 diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index 8fe7fe5af..a3c00b62d 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants) +void initialiseVariables(double *constants, double *algebraic) { computedConstants[1] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 726d2e4df..06d47e8fe 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -76,7 +76,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, ExternalVariable externalVariable) +void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = externalVariable(variables, 1); } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index f2e5f8bea..3aea6ecea 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, ExternalVariable externalVariable); +void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 85f1fc1c3..94691a7c9 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -43,7 +43,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, external_variable): +def initialise_variables(constants, algebraic, external_variable): algebraic[1] = external_variable(variables, 1) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index 09bd540e1..1f34a6c51 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index ccb33cdae..e16ebcdbb 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -35,7 +35,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants): +def initialise_variables(constants, algebraic): computed_constants[1] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index 4fec075e2..844244bab 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants) +void initialiseVariables(double *constants, double *algebraic) { constants[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index 09bd540e1..1f34a6c51 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index 44cf1813a..1f58e7d6f 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -35,7 +35,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants): +def initialise_variables(constants, algebraic): constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index 496cd753d..f4791714a 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -60,7 +60,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants) +void initialiseVariables(double *constants, double *algebraic) { computedConstants[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index 9b095efd7..214a248c0 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index 09de22b37..af04c489b 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -34,7 +34,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants): +def initialise_variables(constants, algebraic): computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 50204c636..be8b6b29a 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { computedConstants[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index 8f773b690..a78dbb906 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 24dc85a5d..273c43ba4 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): computed_constants[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 4350ef5f0..fba3aa00f 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { computedConstants[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index 83c078386..e05d29846 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 710d4a6bd..eb6e7b424 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): computed_constants[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 3f88fde85..212c1b6f5 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { computedConstants[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index 8fb87aae1..ba0e44b67 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 0527bf97d..2407fcadf 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): computed_constants[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index bff87c275..a8b8f710f 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { computedConstants[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index c473a17f5..a33a6c600 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index c17f55153..4eda262a8 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): computed_constants[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 7cad55350..105a0833d 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -91,7 +91,7 @@ void findRoot0(double *variables) algebraic[0] = u[0]; } -void initialiseVariables(double *constants) +void initialiseVariables(double *constants, double *algebraic) { algebraic[0] = 1.0; computedConstants[0] = 3.0; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index bfb49ec7c..d38d0c08e 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, ExternalVariable externalVariable) +void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) { computedConstants[0] = 3.0; computedConstants[1] = 5.0; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index f2e5f8bea..3aea6ecea 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, ExternalVariable externalVariable); +void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index c50b81426..15e43a6c7 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -45,7 +45,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, external_variable): +def initialise_variables(constants, algebraic, external_variable): computed_constants[0] = 3.0 computed_constants[1] = 5.0 computed_constants[2] = 7.0 diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index 09bd540e1..1f34a6c51 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 36471b519..df36f9d08 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -58,7 +58,7 @@ def find_root_0(variables): algebraic[0] = u[0] -def initialise_variables(constants): +def initialise_variables(constants, algebraic): algebraic[0] = 1.0 computed_constants[0] = 3.0 computed_constants[1] = 5.0 diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index 8c0c46b90..0dbe3d9a8 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -98,7 +98,7 @@ void findRoot0(double *variables) algebraic[2] = u[2]; } -void initialiseVariables(double *constants) +void initialiseVariables(double *constants, double *algebraic) { algebraic[0] = 1.0; algebraic[1] = 1.0; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index 9c4390a45..20d7d3dd9 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 5152bedc3..2e9fe582c 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -65,7 +65,7 @@ def find_root_0(variables): algebraic[2] = u[2] -def initialise_variables(constants): +def initialise_variables(constants, algebraic): algebraic[0] = 1.0 algebraic[1] = 1.0 algebraic[2] = 1.0 diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index f4891c4a7..14f3025e2 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, ExternalVariable externalVariable) +void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = externalVariable(variables, 0); algebraic[1] = externalVariable(variables, 1); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index 4a61d58c7..ec5b81c77 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, ExternalVariable externalVariable); +void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index c48580961..b7f5d99b6 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -44,7 +44,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, external_variable): +def initialise_variables(constants, algebraic, external_variable): algebraic[0] = external_variable(variables, 0) algebraic[1] = external_variable(variables, 1) algebraic[2] = external_variable(variables, 2) diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index 6ec8b1670..dec7a4953 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -97,7 +97,7 @@ void findRoot0(double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *constants) +void initialiseVariables(double *constants, double *algebraic) { constants[0] = 3.0; constants[1] = 5.0; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index 9c4390a45..20d7d3dd9 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 4b3aefa55..a38ce9d1e 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -64,7 +64,7 @@ def find_root_0(variables): algebraic[1] = u[1] -def initialise_variables(constants): +def initialise_variables(constants, algebraic): constants[0] = 3.0 constants[1] = 5.0 algebraic[1] = 1.0 diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index 374b6387c..1cfcef840 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -97,7 +97,7 @@ void findRoot0(double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *constants) +void initialiseVariables(double *constants, double *algebraic) { constants[0] = 3.0; constants[1] = 5.0; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index 9c4390a45..20d7d3dd9 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 26d826e4c..a7badc953 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -64,7 +64,7 @@ def find_root_0(variables): algebraic[1] = u[1] -def initialise_variables(constants): +def initialise_variables(constants, algebraic): constants[0] = 3.0 constants[1] = 5.0 algebraic[0] = 1.0 diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index 9aa43b5ee..48c8e8533 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants) +void initialiseVariables(double *constants, double *algebraic) { computedConstants[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index 9b095efd7..214a248c0 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 2d8071055..34185c7ef 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -35,7 +35,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants): +def initialise_variables(constants, algebraic): computed_constants[0] = 1.0 diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index 4fb93ec8e..5e019e3e4 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -63,7 +63,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants) +void initialiseVariables(double *constants, double *algebraic) { constants[0] = 0.01; constants[1] = 0.0011; diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 2cf2258ce..daa7e0447 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, ExternalVariable externalVariable) +void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = externalVariable(variables, 1); algebraic[2] = externalVariable(variables, 2); diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 60a5dac8e..c7ef02ef1 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, ExternalVariable externalVariable); +void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 60c18b4a8..3d16a465a 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -45,7 +45,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, external_variable): +def initialise_variables(constants, algebraic, external_variable): algebraic[1] = external_variable(variables, 1) algebraic[2] = external_variable(variables, 2) diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index adc63ee0d..01b945a3a 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index 632242c00..a8a99bf87 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -37,7 +37,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants): +def initialise_variables(constants, algebraic): constants[0] = 0.01 constants[1] = 0.0011 diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index f37a28dea..4e23c77de 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index d33f9c169..e55d0f0e3 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index ce2e8a5f3..ce8c7b28a 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): states[0] = 1.0 states[1] = 0.0 diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index 9c4aec544..f7fd19efa 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -43,7 +43,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants): +def initialise_variables(constants, algebraic): constants[0] = 1.1 constants[1] = 21262500.0 constants[2] = 150.0 diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index 121c73290..d9a740db5 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 123.0; states[0] = constants[0]; diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index b5e1553fd..c7fc1bb53 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 8f685b2ab..ec5d060f2 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 123.0 states[0] = constants[0] diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 89d15758a..096f85064 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -62,7 +62,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants) +void initialiseVariables(double *constants, double *algebraic) { constants[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index 57ef15ccd..d7919125e 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index 179fc7bf5..b6ea3f00d 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -36,7 +36,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants): +def initialise_variables(constants, algebraic): constants[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index cc090e14d..053937550 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index b5e1553fd..c7fc1bb53 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index db91581c9..3be023c6f 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 7129623ca..4ebce78ef 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index b5e1553fd..c7fc1bb53 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index efe00b6e4..8ee327e2a 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index 27254205c..4ae30b4c2 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 123.0; states[1] = 0.001*789.0; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index 6a5fb1488..dd0b1fd5c 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index bc5026954..f40677357 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): states[0] = 123.0 states[1] = 0.001*789.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index c7b46d5af..53f341688 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 123.0; constants[1] = 789.0; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 5ca5788bc..7267fab5d 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 5e1c748cd..aff5ec527 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 123.0 constants[1] = 789.0 states[0] = constants[0] diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index 93a512d31..3f3b30f11 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 3.0; states[1] = 5.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index 319a116d0..351e9dc86 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index 8ec3b32d4..bd8f7d253 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): states[0] = 3.0 states[1] = 5.0 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index c8fa6eabe..cc5275106 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 3.0; states[1] = 7.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 52fda2a3b..487f6a748 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index a5d2a5ec0..110dcd6ff 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): states[0] = 3.0 states[1] = 7.0 states[2] = 11.0 diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index a21add9d8..0490c2375 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -146,7 +146,7 @@ void findRoot1(double voi, double *states, double *rates, double *variables) algebraic[4] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; constants[1] = 1.0; diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 7a1968fd6..f4325a88b 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index f1bef75dc..9746c76a6 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -99,7 +99,7 @@ def find_root_1(voi, states, rates, variables): algebraic[4] = u[0] -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 1.0 constants[1] = 1.0 constants[2] = 20.0 diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 9367b233f..da657936c 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 006a4093e..2a63e4ec5 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index b60c94ccf..8330f7865 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): states[0] = 0.0 diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 40f092eb9..c55ad5533 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -326,7 +326,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 0.0; constants[1] = 0.0; diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 559cb88d6..91a04ff7d 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index e216fc6a4..bad1cbbfc 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -312,7 +312,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 0.0 constants[1] = 0.0 constants[2] = 140.0 diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 51a8f5289..4a91f69be 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -276,7 +276,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 0.0; constants[1] = 1.0; diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 5aca23091..96bd8c9d2 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 8eda5b420..ae144dacc 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -250,7 +250,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 0.0 constants[1] = 1.0 constants[2] = 1.0309347 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 27a20813d..014c80f3f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { constants[0] = 1.0; constants[1] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index e30a552fd..543f64ae8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 30ad480ea..b5a866b3e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -84,7 +84,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic, external_variable): constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 7a9b63a34..c6bbfef2c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -98,7 +98,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; constants[1] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 2f1d436b5..65b7980a7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { constants[0] = 1.0; constants[1] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index e30a552fd..543f64ae8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index a8489aee6..814ad44aa 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -84,7 +84,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic, external_variable): constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 13e2f7517..c55dd78a0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { constants[0] = 0.0; constants[1] = 0.3; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index e30a552fd..543f64ae8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 378af0a1b..601f71d5c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -84,7 +84,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic, external_variable): constants[0] = 0.0 constants[1] = 0.3 constants[2] = 120.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 543ff0e57..fb3b5d646 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -516,7 +516,7 @@ void findRoot16(double voi, double *states, double *rates, double *variables) rates[3] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; constants[1] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index ea730f343..6dead540c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 258d847ea..39a4dddc7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -436,7 +436,7 @@ def find_root_16(voi, states, rates, variables): rates[3] = u[0] -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 8c59caf7d..63e497727 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { constants[0] = 1.0; constants[1] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index e30a552fd..543f64ae8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 4664272cf..e30ee484b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -84,7 +84,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic, external_variable): constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 327f50b3b..b32cc398f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { constants[0] = 1.0; constants[1] = 0.3; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index e30a552fd..543f64ae8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 70ef952df..5c83fafb0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -84,7 +84,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic, external_variable): constants[0] = 1.0 constants[1] = 0.3 constants[2] = 120.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index c8ecad99e..65138ecb4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { constants[0] = 0.0; constants[1] = 0.3; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index e30a552fd..543f64ae8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 308af3296..11c18b3eb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -84,7 +84,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic, external_variable): constants[0] = 0.0 constants[1] = 0.3 constants[2] = 36.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 02e6af377..4345ee1fe 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { constants[0] = 1.0; constants[1] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index e30a552fd..543f64ae8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 428ac2d5c..72335596c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -84,7 +84,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic, external_variable): constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index cd8f10240..83766cef7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { constants[0] = 1.0; constants[1] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index e30a552fd..543f64ae8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index f4e5fa7ce..e61d98016 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -84,7 +84,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic, external_variable): constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index ea730f343..6dead540c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index a87129a9a..f8e93fd7e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -76,7 +76,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index c159999cd..373332828 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { constants[0] = 1.0; constants[1] = 0.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index e30a552fd..543f64ae8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 1e33ef616..465f5eeec 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -84,7 +84,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic, external_variable): constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index edde742db..f1ddf0593 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -97,7 +97,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 12.0; constants[1] = 0.075; diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index c8b91de02..3814979f5 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 00c9d24e7..085181f77 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -63,7 +63,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 12.0 constants[1] = 0.075 constants[2] = -60.0 diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index abdd00879..60f3dd752 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { computedConstants[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index 319a116d0..351e9dc86 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 775459ff5..8588749b9 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): computed_constants[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index ca6456d26..c8b417840 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { computedConstants[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index 83c078386..e05d29846 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index e6a977d94..c6e079a20 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): computed_constants[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index bc63cf66f..3e90ce418 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index 319a116d0..351e9dc86 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index bb910e5e4..d55e85d83 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index e5fe086ff..b5cd5dc86 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index 83c078386..e05d29846 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 6c83ec466..b8dcc5c70 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 1.0 states[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index ef1c80b1d..1809eb460 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index 319a116d0..351e9dc86 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index 34d1e7d85..fc48945d1 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -43,7 +43,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 796d807b3..900aefa1a 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index 83c078386..e05d29846 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index bb143cbb1..c9165859b 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -43,7 +43,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index f1165a8a1..c335d5c5a 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; states[0] = -2.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index f46f3ac1b..c97d6682e 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index b442e1d9f..3126c9e26 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 1.0 states[0] = -2.0 states[1] = 0.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 7cfa8679f..57ea6044a 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; states[0] = -2.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index 96b38288f..04133c21e 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 8dccc27dd..20083c659 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 1.0 states[0] = -2.0 states[1] = 0.0 diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 17f5507ae..fe2854380 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 1.0; states[0] = 1.0; diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index 0f14d5268..83e1465e4 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 7d64e5d32..4c4eb266c 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 1.0 states[0] = 1.0 states[1] = 1.0 diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index 69a88e243..988556637 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; states[1] = 1.0; diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index 319a116d0..351e9dc86 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 0e06f1051..38df6674b 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): states[0] = 1.0 states[1] = 1.0 diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index a25eebb91..f1bdfd8f0 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -117,7 +117,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[0] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 0.04; constants[1] = 1.0e4; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index bffe009c7..c32902725 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index bab387d15..97b1fa627 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -73,7 +73,7 @@ def find_root_0(voi, states, rates, variables): algebraic[0] = u[0] -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 0.04 constants[1] = 1.0e4 constants[2] = 3.0e7 diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 403affc05..d304b17f9 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -83,7 +83,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 0.04; constants[1] = 1.0e4; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index bffe009c7..c32902725 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 1faef1ab5..c4401eb26 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -49,7 +49,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 0.04 constants[1] = 1.0e4 constants[2] = 3.0e7 diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index d13cfac71..afc9fc26a 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -87,7 +87,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 0.0; constants[1] = 0.75; diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index d6150b9fc..b3f715a2b 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 98456bf5f..ae30609e4 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -57,7 +57,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 0.0 constants[1] = 0.75 computed_constants[0] = 2.0/3.14159265358979 diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index a99d9f146..0103461a2 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -84,7 +84,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, ExternalVariable externalVariable) +void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) { constants[0] = 1.1; constants[1] = 21262500.0; diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 7ddf98552..2bb86e6fb 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, ExternalVariable externalVariable); +void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 06195b207..48f627296 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -51,7 +51,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, external_variable): +def initialise_variables(constants, algebraic, external_variable): constants[0] = 1.1 constants[1] = 21262500.0 constants[2] = 150.0 diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 0c99f7c24..778e44ef9 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants) +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { constants[0] = 7.0; states[0] = constants[0]; diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index 18bcd588e..dac6bf578 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants); +void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index e1fdff433..34bcc5c3a 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants): +def initialise_variables(states, rates, constants, algebraic): constants[0] = 7.0 states[0] = constants[0] From fa807fb43ec1240abb34237d20e2667a14c6d6f0 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 15 Aug 2024 11:30:29 +0200 Subject: [PATCH 24/74] GeneratorProfile: fixed a small issue with our Python profile. --- src/generatorprofile.cpp | 4 +++- src/generatorprofilesha1values.h | 2 +- tests/resources/coverage/generator/model.modified.profile.py | 5 +++-- tests/resources/coverage/generator/model.py | 5 +++-- .../generator/algebraic_eqn_derivative_on_rhs/model.py | 5 +++-- .../algebraic_eqn_derivative_on_rhs_one_component/model.py | 5 +++-- .../generator/algebraic_eqn_state_var_on_rhs/model.py | 5 +++-- .../algebraic_eqn_state_var_on_rhs_one_component/model.py | 5 +++-- .../generator/cellml_mappings_and_encapsulations/model.py | 5 +++-- .../cellml_state_initialised_using_variable/model.py | 5 +++-- tests/resources/generator/cellml_unit_scaling_rate/model.py | 5 +++-- tests/resources/generator/cellml_unit_scaling_state/model.py | 5 +++-- .../model.py | 5 +++-- .../model.py | 5 +++-- .../generator/cellml_unit_scaling_voi_direct/model.py | 5 +++-- .../generator/cellml_unit_scaling_voi_indirect/model.py | 5 +++-- tests/resources/generator/dae_cellml_1_1_model/model.py | 5 +++-- tests/resources/generator/dependent_eqns/model.py | 5 +++-- .../model.py | 5 +++-- .../model.py | 5 +++-- .../hodgkin_huxley_squid_axon_model_1952/model.algebraic.py | 5 +++-- .../model.computed.constant.py | 5 +++-- .../hodgkin_huxley_squid_axon_model_1952/model.constant.py | 5 +++-- .../hodgkin_huxley_squid_axon_model_1952/model.dae.py | 5 +++-- .../model.dependent.algebraic.py | 5 +++-- .../model.dependent.computed.constant.py | 5 +++-- .../model.dependent.constant.py | 5 +++-- .../model.dependent.state.py | 5 +++-- .../hodgkin_huxley_squid_axon_model_1952/model.external.py | 5 +++-- .../generator/hodgkin_huxley_squid_axon_model_1952/model.py | 5 +++-- .../hodgkin_huxley_squid_axon_model_1952/model.state.py | 5 +++-- tests/resources/generator/noble_model_1962/model.py | 5 +++-- tests/resources/generator/ode_computed_var_on_rhs/model.py | 5 +++-- .../generator/ode_computed_var_on_rhs_one_component/model.py | 5 +++-- tests/resources/generator/ode_const_var_on_rhs/model.py | 5 +++-- .../generator/ode_const_var_on_rhs_one_component/model.py | 5 +++-- tests/resources/generator/ode_constant_on_rhs/model.py | 5 +++-- .../generator/ode_constant_on_rhs_one_component/model.py | 5 +++-- .../resources/generator/ode_multiple_dependent_odes/model.py | 5 +++-- .../ode_multiple_dependent_odes_one_component/model.py | 5 +++-- .../generator/ode_multiple_odes_with_same_name/model.py | 5 +++-- tests/resources/generator/ode_unknown_var_on_rhs/model.py | 5 +++-- tests/resources/generator/robertson_model_1966/model.dae.py | 5 +++-- tests/resources/generator/robertson_model_1966/model.ode.py | 5 +++-- tests/resources/generator/sine_model_imports/model.py | 5 +++-- .../generator/variable_initialised_using_a_constant/model.py | 5 +++-- 46 files changed, 136 insertions(+), 90 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 18d29dc32..997fa4bfb 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -707,7 +707,9 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mImplementationVoiInfoString = "VOI_INFO = [CODE]\n"; mInterfaceStateInfoString = ""; - mImplementationStateInfoString = "STATE_INFO = [CODE]\n"; + mImplementationStateInfoString = "STATE_INFO = [\n" + "[CODE]" + "]\n"; mInterfaceConstantInfoString = ""; mImplementationConstantInfoString = "CONSTANT_INFO = [\n" diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 2b8290157..cf522db03 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -25,6 +25,6 @@ namespace libcellml { * See docs/dev_utilities.rst for further information. */ static const char C_GENERATOR_PROFILE_SHA1[] = "2d4d14df0a454d95e32e1172503d529834c42588"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "9f79e69847b6ec2faeb7f56f476ef2542a901b1f"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "5ff1e7cc237b3e7eb1153b6d421df842731c6394"; } // namespace libcellml diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 97288e284..0ebd3706c 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} - +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] CONSTANT_INFO = [ {"name": "m", "units": "dimensionless", "component": "my_component"}, diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 87832d45c..41f5145cd 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} - +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] CONSTANT_INFO = [ {"name": "m", "units": "dimensionless", "component": "my_component"}, diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 273c43ba4..c209063f4 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -STATE_INFO = {"name": "v", "units": "dimensionless", "component": "my_ode"} - +STATE_INFO = [ + {"name": "v", "units": "dimensionless", "component": "my_ode"} +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index eb6e7b424..bf7e73949 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -STATE_INFO = {"name": "v", "units": "dimensionless", "component": "my_component"} - +STATE_INFO = [ + {"name": "v", "units": "dimensionless", "component": "my_component"} +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 2407fcadf..461603bea 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode"} - +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_ode"} +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 4eda262a8..626e04c14 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "my_model"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_model"} - +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_model"} +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index ce8c7b28a..cc23dc6d1 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -14,9 +14,10 @@ VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -STATE_INFO = {"name": "y", "units": "mM", "component": "circle_y_implementation"}, +STATE_INFO = [ + {"name": "y", "units": "mM", "component": "circle_y_implementation"}, {"name": "x", "units": "mM", "component": "circle_x"} - +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index ec5d060f2..c05b32ce6 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -STATE_INFO = {"name": "x", "units": "mV", "component": "main"} - +STATE_INFO = [ + {"name": "x", "units": "mV", "component": "main"} +] CONSTANT_INFO = [ {"name": "k", "units": "mV", "component": "constants"} diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 3be023c6f..1e36dfbf7 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -STATE_INFO = {"name": "k", "units": "mM", "component": "states"} - +STATE_INFO = [ + {"name": "k", "units": "mM", "component": "states"} +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index 8ee327e2a..b76901fc5 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -STATE_INFO = {"name": "k", "units": "mM", "component": "states"} - +STATE_INFO = [ + {"name": "k", "units": "mM", "component": "states"} +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index f40677357..212fca2d8 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -14,9 +14,10 @@ VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -STATE_INFO = {"name": "k1", "units": "mM", "component": "main"}, +STATE_INFO = [ + {"name": "k1", "units": "mM", "component": "main"}, {"name": "k2", "units": "M", "component": "main"} - +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index aff5ec527..9f1c08de9 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -14,9 +14,10 @@ VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -STATE_INFO = {"name": "k1", "units": "mM", "component": "main"}, +STATE_INFO = [ + {"name": "k1", "units": "mM", "component": "main"}, {"name": "k2", "units": "M", "component": "main"} - +] CONSTANT_INFO = [ {"name": "k1_cst", "units": "mM", "component": "constants"}, diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index bd8f7d253..bed26c278 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -14,9 +14,10 @@ VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "main"}, +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "main"}, {"name": "y", "units": "dimensionless", "component": "main"} - +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index 110dcd6ff..5d5db3945 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -14,10 +14,11 @@ VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -STATE_INFO = {"name": "x", "units": "metre", "component": "t_in_s"}, +STATE_INFO = [ + {"name": "x", "units": "metre", "component": "t_in_s"}, {"name": "x", "units": "metre", "component": "t_in_ms"}, {"name": "x", "units": "metre", "component": "t_in_ks"} - +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 9746c76a6..4b0ae9b51 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -14,9 +14,10 @@ VOI_INFO = {"name": "t", "units": "second", "component": "main"} -STATE_INFO = {"name": "q_1", "units": "coulomb", "component": "main"}, +STATE_INFO = [ + {"name": "q_1", "units": "coulomb", "component": "main"}, {"name": "v_3", "units": "C_per_s", "component": "main"} - +] CONSTANT_INFO = [ {"name": "v_in", "units": "C_per_s", "component": "main"}, diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index 8330f7865..b415fdb96 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "time", "units": "second", "component": "my_component"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} - +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index bad1cbbfc..0a32422fc 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -14,7 +14,8 @@ VOI_INFO = {"name": "time", "units": "second", "component": "environment"} -STATE_INFO = {"name": "Ca_sub", "units": "millimolar", "component": "Ca_dynamics"}, +STATE_INFO = [ + {"name": "Ca_sub", "units": "millimolar", "component": "Ca_dynamics"}, {"name": "Nai_", "units": "millimolar", "component": "Nai_concentration"}, {"name": "Ca_jsr", "units": "millimolar", "component": "Ca_dynamics"}, {"name": "O", "units": "dimensionless", "component": "Ca_SR_release"}, @@ -47,7 +48,7 @@ {"name": "paS", "units": "dimensionless", "component": "i_Kr_pa_gate"}, {"name": "n", "units": "dimensionless", "component": "i_Ks_n_gate"}, {"name": "a", "units": "dimensionless", "component": "i_KACh_a_gate"} - +] CONSTANT_INFO = [ {"name": "ACh", "units": "millimolar", "component": "Rate_modulation_experiments"}, diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index ae144dacc..5366a19b3 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -14,7 +14,8 @@ VOI_INFO = {"name": "time", "units": "second", "component": "environment"} -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "m", "units": "dimensionless", "component": "sodium_current_m_gate"}, {"name": "h1", "units": "dimensionless", "component": "sodium_current_h_gate"}, {"name": "h2", "units": "dimensionless", "component": "sodium_current_h_gate"}, @@ -29,7 +30,7 @@ {"name": "P_as", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate"}, {"name": "xs", "units": "dimensionless", "component": "slow_delayed_rectifying_potassium_current_xs_gate"}, {"name": "y", "units": "dimensionless", "component": "hyperpolarisation_activated_current_y_gate"} - +] CONSTANT_INFO = [ {"name": "dCell", "units": "dimensionless", "component": "membrane"}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index b5a866b3e..456ad3deb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -15,11 +15,12 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 814ad44aa..aa2ab1b23 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -15,11 +15,12 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 601f71d5c..fabc48c20 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -15,11 +15,12 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "E_R", "units": "millivolt", "component": "membrane"}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 39a4dddc7..d1fba9fff 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -14,11 +14,12 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index e30ee484b..81e680d3d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -15,11 +15,12 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 5c83fafb0..9cf6ce4c1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -15,11 +15,12 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 11c18b3eb..1dde1527f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -15,11 +15,12 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "E_R", "units": "millivolt", "component": "membrane"}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 72335596c..9fd00c61b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -15,9 +15,10 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, +STATE_INFO = [ + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index e61d98016..8813c2b02 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -15,10 +15,11 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, +STATE_INFO = [ + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index f8e93fd7e..82b0b193e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -14,11 +14,12 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 465f5eeec..c13120d5c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -15,10 +15,11 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 085181f77..04b15d26b 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -14,11 +14,12 @@ VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} -STATE_INFO = {"name": "V", "units": "millivolt", "component": "membrane"}, +STATE_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} - +] CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 8588749b9..607d6c441 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode"} - +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_ode"} +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index c6e079a20..11486d4f8 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} - +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index d55e85d83..95b5ade5f 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode"} - +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_ode"} +] CONSTANT_INFO = [ {"name": "a", "units": "per_s", "component": "my_ode"} diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index b8dcc5c70..4da1db089 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} - +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] CONSTANT_INFO = [ {"name": "a", "units": "per_s", "component": "my_component"} diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index fc48945d1..f9e8d5488 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode"} - +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_ode"} +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index c9165859b..e32e47341 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"} - +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 3126c9e26..d3a7b6a53 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -14,9 +14,10 @@ VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_x_ode"}, +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_x_ode"}, {"name": "y", "units": "dimensionless", "component": "my_y_ode"} - +] CONSTANT_INFO = [ {"name": "epsilon", "units": "dimensionless", "component": "my_y_ode"} diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 20083c659..28fe3ff9d 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -14,9 +14,10 @@ VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_component"}, +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"}, {"name": "y", "units": "dimensionless", "component": "my_component"} - +] CONSTANT_INFO = [ {"name": "epsilon", "units": "dimensionless", "component": "my_component"} diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 4c4eb266c..c9ff7906f 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -14,9 +14,10 @@ VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_first_ode"}, +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_first_ode"}, {"name": "x", "units": "dimensionless", "component": "my_second_ode"} - +] CONSTANT_INFO = [ {"name": "a", "units": "per_s", "component": "my_second_ode"} diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 38df6674b..825591ba2 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -14,9 +14,10 @@ VOI_INFO = {"name": "t", "units": "second", "component": "environment"} -STATE_INFO = {"name": "x", "units": "dimensionless", "component": "my_ode"}, +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_ode"}, {"name": "y", "units": "dimensionless", "component": "my_ode"} - +] CONSTANT_INFO = [ ] diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 97b1fa627..fdf991695 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -14,9 +14,10 @@ VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} -STATE_INFO = {"name": "y1", "units": "dimensionless", "component": "main"}, +STATE_INFO = [ + {"name": "y1", "units": "dimensionless", "component": "main"}, {"name": "y2", "units": "dimensionless", "component": "main"} - +] CONSTANT_INFO = [ {"name": "k1", "units": "dimensionless", "component": "main"}, diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index c4401eb26..0da019dd3 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -14,10 +14,11 @@ VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} -STATE_INFO = {"name": "y1", "units": "dimensionless", "component": "main"}, +STATE_INFO = [ + {"name": "y1", "units": "dimensionless", "component": "main"}, {"name": "y3", "units": "dimensionless", "component": "main"}, {"name": "y2", "units": "dimensionless", "component": "main"} - +] CONSTANT_INFO = [ {"name": "k1", "units": "dimensionless", "component": "main"}, diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index ae30609e4..68dbffb33 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "x", "units": "dimensionless", "component": "main"} -STATE_INFO = {"name": "sin", "units": "dimensionless", "component": "deriv_approx_sin"} - +STATE_INFO = [ + {"name": "sin", "units": "dimensionless", "component": "deriv_approx_sin"} +] CONSTANT_INFO = [ {"name": "deriv_approx_initial_value", "units": "dimensionless", "component": "main"}, diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 34bcc5c3a..4be9384a6 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -14,8 +14,9 @@ VOI_INFO = {"name": "t", "units": "second", "component": "component_1"} -STATE_INFO = {"name": "X", "units": "dimensionless", "component": "component_1"} - +STATE_INFO = [ + {"name": "X", "units": "dimensionless", "component": "component_1"} +] CONSTANT_INFO = [ {"name": "X_init", "units": "dimensionless", "component": "component_2"} From 71ae73b36db19365cf1646f21b9655beece6c9f6 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 15 Aug 2024 16:08:03 +0200 Subject: [PATCH 25/74] Generator: initialise things in initialiseVariables() in the order of its parameters. --- src/generator.cpp | 34 +++++----- tests/resources/coverage/generator/model.c | 2 +- .../generator/model.implementation.out | 2 +- .../generator/model.modified.profile.c | 2 +- .../generator/model.modified.profile.py | 2 +- tests/resources/coverage/generator/model.out | 2 +- tests/resources/coverage/generator/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../model.c | 4 +- .../model.py | 4 +- .../generator/dae_cellml_1_1_model/model.c | 4 +- .../generator/dae_cellml_1_1_model/model.py | 4 +- .../model.c | 66 +++++++++---------- .../model.py | 66 +++++++++---------- .../model.c | 30 ++++----- .../model.py | 30 ++++----- .../model.algebraic.c | 8 +-- .../model.algebraic.py | 8 +-- .../model.c | 8 +-- .../model.computed.constant.c | 8 +-- .../model.computed.constant.py | 8 +-- .../model.constant.c | 8 +-- .../model.constant.py | 8 +-- .../model.dae.c | 16 ++--- .../model.dae.py | 16 ++--- .../model.dependent.algebraic.c | 8 +-- .../model.dependent.algebraic.py | 8 +-- .../model.dependent.computed.constant.c | 8 +-- .../model.dependent.computed.constant.py | 8 +-- .../model.dependent.constant.c | 6 +- .../model.dependent.constant.py | 6 +- .../model.dependent.state.c | 4 +- .../model.dependent.state.py | 4 +- .../model.external.c | 6 +- .../model.external.py | 6 +- .../model.py | 8 +-- .../model.state.c | 6 +- .../model.state.py | 6 +- .../generator/noble_model_1962/model.c | 8 +-- .../generator/noble_model_1962/model.py | 8 +-- .../generator/ode_computed_var_on_rhs/model.c | 2 +- .../ode_computed_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../generator/ode_const_var_on_rhs/model.c | 2 +- .../generator/ode_const_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../ode_multiple_dependent_odes/model.c | 2 +- .../ode_multiple_dependent_odes/model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- .../ode_multiple_odes_with_same_name/model.c | 2 +- .../ode_multiple_odes_with_same_name/model.py | 2 +- .../robertson_model_1966/model.dae.c | 4 +- .../robertson_model_1966/model.dae.py | 4 +- .../robertson_model_1966/model.ode.c | 6 +- .../robertson_model_1966/model.ode.py | 6 +- .../generator/sine_model_imports/model.c | 2 +- .../generator/sine_model_imports/model.py | 2 +- .../model.c | 2 +- .../model.py | 2 +- 71 files changed, 259 insertions(+), 259 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index d47bdf7ce..0404698ab 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1807,6 +1807,23 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st mModel->hasExternalVariables()); if (!implementationInitialiseVariablesMethodString.empty()) { + // Initialise our states. + + std::string methodBody; + + for (const auto &state : mModel->states()) { + methodBody += generateInitialisationCode(state); + } + + // Use an initial guess of zero for rates computed using an NLA system + // (see the note below). + + for (const auto &state : mModel->states()) { + if (state->equation(0)->type() == AnalyserEquation::Type::NLA) { + methodBody += generateZeroInitialisationCode(state); + } + } + // Initialise our constants and our algebraic variables that have an // initial value. Also use an initial guess of zero for computed // constants and algebraic variables computed using an NLA system. @@ -1817,8 +1834,6 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st // guess. We use an initial guess of zero, which is fine since // such an NLA system has only one solution. - std::string methodBody; - for (const auto &variable : variables(mModel)) { switch (variable->type()) { case AnalyserVariable::Type::CONSTANT: @@ -1849,21 +1864,6 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st } } - // Initialise our states. - - for (const auto &state : mModel->states()) { - methodBody += generateInitialisationCode(state); - } - - // Use an initial guess of zero for rates computed using an NLA system - // (see the note above). - - for (const auto &state : mModel->states()) { - if (state->equation(0)->type() == AnalyserEquation::Type::NLA) { - methodBody += generateZeroInitialisationCode(state); - } - } - // Initialise our external variables. if (mModel->hasExternalVariables()) { diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 95cb0e4fb..b6479b2b8 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -407,6 +407,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = 0.0; constants[0] = 1.0; constants[1] = 2.0; constants[2] = 3.0; @@ -428,7 +429,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[187] = NAN; computedConstants[198] = 1.0; computedConstants[199] = 3.0; - states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 1bd2a352f..ab220a0b3 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -170,6 +170,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = 0.0; constants[0] = 1.0; constants[1] = 2.0; constants[2] = 3.0; @@ -191,7 +192,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[187] = NAN; computedConstants[198] = 1.0; computedConstants[199] = 3.0; - states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 8b95e5994..96320e6c0 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -407,6 +407,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = 0.0; constants[0] = 1.0; constants[1] = 2.0; constants[2] = 3.0; @@ -428,7 +429,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[187] = NAN; computedConstants[198] = 1.0; computedConstants[199] = 3.0; - states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 0ebd3706c..eea22df56 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -384,6 +384,7 @@ def find_root_0(voi, states, rates, variables): def initialise_variables(states, rates, constants, algebraic): + states[0] = 0.0 constants[0] = 1.0 constants[1] = 2.0 constants[2] = 3.0 @@ -405,7 +406,6 @@ def initialise_variables(states, rates, constants, algebraic): computed_constants[187] = nan computed_constants[198] = 1.0 computed_constants[199] = 3.0 - states[0] = 0.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index 087fc8b7b..3f57e2f5c 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -118,6 +118,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = 0.0; constants[0] = 1.0; constants[1] = 2.0; constants[2] = 3.0; @@ -139,7 +140,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[187] = NAN; computedConstants[198] = 1.0; computedConstants[199] = 3.0; - states[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 41f5145cd..8e305579f 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -384,6 +384,7 @@ def find_root_0(voi, states, rates, variables): def initialise_variables(states, rates, constants, algebraic): + states[0] = 0.0 constants[0] = 1.0 constants[1] = 2.0 constants[2] = 3.0 @@ -405,7 +406,6 @@ def initialise_variables(states, rates, constants, algebraic): computed_constants[187] = nan computed_constants[198] = 1.0 computed_constants[199] = 3.0 - states[0] = 0.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index be8b6b29a..346113323 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -81,8 +81,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - computedConstants[0] = 1.0; states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index c209063f4..4c38d6136 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -47,8 +47,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - computed_constants[0] = 1.0 states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index fba3aa00f..b986dc276 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -81,8 +81,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - computedConstants[0] = 1.0; states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index bf7e73949..45d1c49bf 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -47,8 +47,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - computed_constants[0] = 1.0 states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 212c1b6f5..2435f13f6 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -81,8 +81,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - computedConstants[0] = 1.0; states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 461603bea..3f9078205 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -47,8 +47,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - computed_constants[0] = 1.0 states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index a8b8f710f..1c1013f49 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -81,8 +81,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - computedConstants[0] = 1.0; states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 626e04c14..921b10db4 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -47,8 +47,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - computed_constants[0] = 1.0 states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index d9a740db5..311dad8ea 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -80,8 +80,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - constants[0] = 123.0; states[0] = constants[0]; + constants[0] = 123.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index c05b32ce6..7da7403e9 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -46,8 +46,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - constants[0] = 123.0 states[0] = constants[0] + constants[0] = 123.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index 53f341688..d4036cd8f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -82,10 +82,10 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - constants[0] = 123.0; - constants[1] = 789.0; states[0] = constants[0]; states[1] = 0.001*constants[1]; + constants[0] = 123.0; + constants[1] = 789.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 9f1c08de9..f60e5e970 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -48,10 +48,10 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - constants[0] = 123.0 - constants[1] = 789.0 states[0] = constants[0] states[1] = 0.001*constants[1] + constants[0] = 123.0 + constants[1] = 789.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 0490c2375..d32cd7b90 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -148,6 +148,8 @@ void findRoot1(double voi, double *states, double *rates, double *variables) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = 1.0; + states[1] = 0.0; constants[0] = 1.0; constants[1] = 1.0; constants[2] = 20.0; @@ -155,8 +157,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[4] = 10.0; algebraic[0] = 0.0; algebraic[4] = 0.0; - states[0] = 1.0; - states[1] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 4b0ae9b51..a65bd2932 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -101,6 +101,8 @@ def find_root_1(voi, states, rates, variables): def initialise_variables(states, rates, constants, algebraic): + states[0] = 1.0 + states[1] = 0.0 constants[0] = 1.0 constants[1] = 1.0 constants[2] = 20.0 @@ -108,8 +110,6 @@ def initialise_variables(states, rates, constants, algebraic): constants[4] = 10.0 algebraic[0] = 0.0 algebraic[4] = 0.0 - states[0] = 1.0 - states[1] = 0.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index c55ad5533..20d93a9cc 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -328,6 +328,39 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = 6.226104e-5; + states[1] = 5.0; + states[2] = 0.409551; + states[3] = 6.181512e-9; + states[4] = 0.9308; + states[5] = 0.069199; + states[6] = 4.595622e-10; + states[7] = 9.15641e-6; + states[8] = 0.435148; + states[9] = 0.017929; + states[10] = 0.259947; + states[11] = 0.653777; + states[12] = 0.217311; + states[13] = 0.158521; + states[14] = 0.138975; + states[15] = -47.787168; + states[16] = 0.009508; + states[17] = 0.003058; + states[18] = 0.447724; + states[19] = 0.845304; + states[20] = 0.011845; + states[21] = 0.844449; + states[22] = 0.846702; + states[23] = 0.001921; + states[24] = 0.020484; + states[25] = 0.268909; + states[26] = 0.014523; + states[27] = 0.430836; + states[28] = 0.709051; + states[29] = 0.011068; + states[30] = 0.283185; + states[31] = 0.1162; + states[32] = 0.00277; constants[0] = 0.0; constants[1] = 0.0; constants[2] = 140.0; @@ -419,39 +452,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[88] = 0.00065; constants[89] = 1.0; constants[90] = 0.00345; - states[0] = 6.226104e-5; - states[1] = 5.0; - states[2] = 0.409551; - states[3] = 6.181512e-9; - states[4] = 0.9308; - states[5] = 0.069199; - states[6] = 4.595622e-10; - states[7] = 9.15641e-6; - states[8] = 0.435148; - states[9] = 0.017929; - states[10] = 0.259947; - states[11] = 0.653777; - states[12] = 0.217311; - states[13] = 0.158521; - states[14] = 0.138975; - states[15] = -47.787168; - states[16] = 0.009508; - states[17] = 0.003058; - states[18] = 0.447724; - states[19] = 0.845304; - states[20] = 0.011845; - states[21] = 0.844449; - states[22] = 0.846702; - states[23] = 0.001921; - states[24] = 0.020484; - states[25] = 0.268909; - states[26] = 0.014523; - states[27] = 0.430836; - states[28] = 0.709051; - states[29] = 0.011068; - states[30] = 0.283185; - states[31] = 0.1162; - states[32] = 0.00277; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 0a32422fc..379a01e73 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -314,6 +314,39 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): + states[0] = 6.226104e-5 + states[1] = 5.0 + states[2] = 0.409551 + states[3] = 6.181512e-9 + states[4] = 0.9308 + states[5] = 0.069199 + states[6] = 4.595622e-10 + states[7] = 9.15641e-6 + states[8] = 0.435148 + states[9] = 0.017929 + states[10] = 0.259947 + states[11] = 0.653777 + states[12] = 0.217311 + states[13] = 0.158521 + states[14] = 0.138975 + states[15] = -47.787168 + states[16] = 0.009508 + states[17] = 0.003058 + states[18] = 0.447724 + states[19] = 0.845304 + states[20] = 0.011845 + states[21] = 0.844449 + states[22] = 0.846702 + states[23] = 0.001921 + states[24] = 0.020484 + states[25] = 0.268909 + states[26] = 0.014523 + states[27] = 0.430836 + states[28] = 0.709051 + states[29] = 0.011068 + states[30] = 0.283185 + states[31] = 0.1162 + states[32] = 0.00277 constants[0] = 0.0 constants[1] = 0.0 constants[2] = 140.0 @@ -405,39 +438,6 @@ def initialise_variables(states, rates, constants, algebraic): constants[88] = 0.00065 constants[89] = 1.0 constants[90] = 0.00345 - states[0] = 6.226104e-5 - states[1] = 5.0 - states[2] = 0.409551 - states[3] = 6.181512e-9 - states[4] = 0.9308 - states[5] = 0.069199 - states[6] = 4.595622e-10 - states[7] = 9.15641e-6 - states[8] = 0.435148 - states[9] = 0.017929 - states[10] = 0.259947 - states[11] = 0.653777 - states[12] = 0.217311 - states[13] = 0.158521 - states[14] = 0.138975 - states[15] = -47.787168 - states[16] = 0.009508 - states[17] = 0.003058 - states[18] = 0.447724 - states[19] = 0.845304 - states[20] = 0.011845 - states[21] = 0.844449 - states[22] = 0.846702 - states[23] = 0.001921 - states[24] = 0.020484 - states[25] = 0.268909 - states[26] = 0.014523 - states[27] = 0.430836 - states[28] = 0.709051 - states[29] = 0.011068 - states[30] = 0.283185 - states[31] = 0.1162 - states[32] = 0.00277 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 4a91f69be..95cebcd3a 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -278,6 +278,21 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = -39.013558536; + states[1] = 0.092361701692; + states[2] = 0.015905380261; + states[3] = 0.01445216109; + states[4] = 0.48779845203; + states[5] = 0.04804900895; + states[6] = 0.038968420558; + states[7] = 0.42074047435; + states[8] = 0.064402950262; + states[9] = 0.29760539675; + states[10] = 0.87993375273; + states[11] = 0.13034201158; + states[12] = 0.46960956028; + states[13] = 0.082293827208; + states[14] = 0.03889291759; constants[0] = 0.0; constants[1] = 1.0; constants[2] = 1.0309347; @@ -388,21 +403,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[107] = 0.0055; constants[108] = 0.0005465; constants[109] = 0.006875; - states[0] = -39.013558536; - states[1] = 0.092361701692; - states[2] = 0.015905380261; - states[3] = 0.01445216109; - states[4] = 0.48779845203; - states[5] = 0.04804900895; - states[6] = 0.038968420558; - states[7] = 0.42074047435; - states[8] = 0.064402950262; - states[9] = 0.29760539675; - states[10] = 0.87993375273; - states[11] = 0.13034201158; - states[12] = 0.46960956028; - states[13] = 0.082293827208; - states[14] = 0.03889291759; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 5366a19b3..0b6a2012a 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -252,6 +252,21 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): + states[0] = -39.013558536 + states[1] = 0.092361701692 + states[2] = 0.015905380261 + states[3] = 0.01445216109 + states[4] = 0.48779845203 + states[5] = 0.04804900895 + states[6] = 0.038968420558 + states[7] = 0.42074047435 + states[8] = 0.064402950262 + states[9] = 0.29760539675 + states[10] = 0.87993375273 + states[11] = 0.13034201158 + states[12] = 0.46960956028 + states[13] = 0.082293827208 + states[14] = 0.03889291759 constants[0] = 0.0 constants[1] = 1.0 constants[2] = 1.0309347 @@ -362,21 +377,6 @@ def initialise_variables(states, rates, constants, algebraic): constants[107] = 0.0055 constants[108] = 0.0005465 constants[109] = 0.006875 - states[0] = -39.013558536 - states[1] = 0.092361701692 - states[2] = 0.015905380261 - states[3] = 0.01445216109 - states[4] = 0.48779845203 - states[5] = 0.04804900895 - states[6] = 0.038968420558 - states[7] = 0.42074047435 - states[8] = 0.064402950262 - states[9] = 0.29760539675 - states[10] = 0.87993375273 - states[11] = 0.13034201158 - states[12] = 0.46960956028 - states[13] = 0.082293827208 - states[14] = 0.03889291759 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 014c80f3f..79638165e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -115,15 +115,15 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; constants[0] = 1.0; constants[1] = 0.0; constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; algebraic[0] = externalVariable(voi, states, rates, variables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 456ad3deb..9d302d251 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -86,15 +86,15 @@ def create_externals_array(): def initialise_variables(voi, states, rates, constants, algebraic, external_variable): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 algebraic[0] = external_variable(voi, states, rates, variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index c6bbfef2c..055c69796 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -100,15 +100,15 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; constants[0] = 1.0; constants[1] = 0.0; constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 65b7980a7..30d273c85 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -115,15 +115,15 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; constants[0] = 1.0; constants[1] = 0.0; constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; algebraic[4] = externalVariable(voi, states, rates, variables, 4); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index aa2ab1b23..110c67f6c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -86,15 +86,15 @@ def create_externals_array(): def initialise_variables(voi, states, rates, constants, algebraic, external_variable): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 algebraic[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index c55dd78a0..e006edcb5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -115,14 +115,14 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { - constants[0] = 0.0; - constants[1] = 0.3; - constants[2] = 120.0; - constants[3] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; + constants[0] = 0.0; + constants[1] = 0.3; + constants[2] = 120.0; + constants[3] = 36.0; algebraic[4] = externalVariable(voi, states, rates, variables, 4); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index fabc48c20..95ab1649b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -86,14 +86,14 @@ def create_externals_array(): def initialise_variables(voi, states, rates, constants, algebraic, external_variable): - constants[0] = 0.0 - constants[1] = 0.3 - constants[2] = 120.0 - constants[3] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 + constants[0] = 0.0 + constants[1] = 0.3 + constants[2] = 120.0 + constants[3] = 36.0 algebraic[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index fb3b5d646..0e805880e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -518,6 +518,14 @@ void findRoot16(double voi, double *states, double *rates, double *variables) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; + rates[0] = 0.0; + rates[1] = 0.0; + rates[2] = 0.0; + rates[3] = 0.0; constants[0] = 1.0; constants[1] = 0.0; constants[2] = 0.3; @@ -536,14 +544,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl algebraic[7] = 0.0; algebraic[8] = 0.0; algebraic[9] = 0.0; - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; - rates[0] = 0.0; - rates[1] = 0.0; - rates[2] = 0.0; - rates[3] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index d1fba9fff..d42b47c11 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -438,6 +438,14 @@ def find_root_16(voi, states, rates, variables): def initialise_variables(states, rates, constants, algebraic): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 + rates[0] = 0.0 + rates[1] = 0.0 + rates[2] = 0.0 + rates[3] = 0.0 constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 @@ -456,14 +464,6 @@ def initialise_variables(states, rates, constants, algebraic): algebraic[7] = 0.0 algebraic[8] = 0.0 algebraic[9] = 0.0 - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 - rates[0] = 0.0 - rates[1] = 0.0 - rates[2] = 0.0 - rates[3] = 0.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 63e497727..c2349a909 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -115,15 +115,15 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.05; + states[3] = 0.325; constants[0] = 1.0; constants[1] = 0.0; constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.05; - states[3] = 0.325; algebraic[9] = externalVariable(voi, states, rates, variables, 9); algebraic[0] = externalVariable(voi, states, rates, variables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 81e680d3d..a7da90472 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -86,15 +86,15 @@ def create_externals_array(): def initialise_variables(voi, states, rates, constants, algebraic, external_variable): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 algebraic[9] = external_variable(voi, states, rates, variables, 9) algebraic[0] = external_variable(voi, states, rates, variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index b32cc398f..9ae267b45 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -115,14 +115,14 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { - constants[0] = 1.0; - constants[1] = 0.3; - constants[2] = 120.0; - constants[3] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; + constants[0] = 1.0; + constants[1] = 0.3; + constants[2] = 120.0; + constants[3] = 36.0; algebraic[11] = externalVariable(voi, states, rates, variables, 11); algebraic[4] = externalVariable(voi, states, rates, variables, 4); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 9cf6ce4c1..8ecf9444b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -86,14 +86,14 @@ def create_externals_array(): def initialise_variables(voi, states, rates, constants, algebraic, external_variable): - constants[0] = 1.0 - constants[1] = 0.3 - constants[2] = 120.0 - constants[3] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 + constants[0] = 1.0 + constants[1] = 0.3 + constants[2] = 120.0 + constants[3] = 36.0 algebraic[11] = external_variable(voi, states, rates, variables, 11) algebraic[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 65138ecb4..7e6747363 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -115,13 +115,13 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { - constants[0] = 0.0; - constants[1] = 0.3; - constants[2] = 36.0; states[0] = 0.0; states[1] = 0.6; states[2] = 0.05; states[3] = 0.325; + constants[0] = 0.0; + constants[1] = 0.3; + constants[2] = 36.0; algebraic[5] = externalVariable(voi, states, rates, variables, 5); algebraic[4] = externalVariable(voi, states, rates, variables, 4); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 1dde1527f..64f4a8c1f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -86,13 +86,13 @@ def create_externals_array(): def initialise_variables(voi, states, rates, constants, algebraic, external_variable): - constants[0] = 0.0 - constants[1] = 0.3 - constants[2] = 36.0 states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 states[3] = 0.325 + constants[0] = 0.0 + constants[1] = 0.3 + constants[2] = 36.0 algebraic[5] = external_variable(voi, states, rates, variables, 5) algebraic[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 4345ee1fe..7d42c647f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -115,13 +115,13 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { + states[0] = 0.6; + states[1] = 0.325; constants[0] = 1.0; constants[1] = 0.0; constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - states[0] = 0.6; - states[1] = 0.325; algebraic[1] = externalVariable(voi, states, rates, variables, 1); algebraic[5] = externalVariable(voi, states, rates, variables, 5); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 9fd00c61b..d9285aa42 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -86,13 +86,13 @@ def create_externals_array(): def initialise_variables(voi, states, rates, constants, algebraic, external_variable): + states[0] = 0.6 + states[1] = 0.325 constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - states[0] = 0.6 - states[1] = 0.325 algebraic[1] = external_variable(voi, states, rates, variables, 1) algebraic[5] = external_variable(voi, states, rates, variables, 5) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 83766cef7..bb4ff207f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -115,14 +115,14 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { + states[0] = 0.6; + states[1] = 0.05; + states[2] = 0.325; constants[0] = 1.0; constants[1] = 0.0; constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - states[0] = 0.6; - states[1] = 0.05; - states[2] = 0.325; algebraic[1] = externalVariable(voi, states, rates, variables, 1); algebraic[9] = externalVariable(voi, states, rates, variables, 9); algebraic[4] = externalVariable(voi, states, rates, variables, 4); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 8813c2b02..e3b132256 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -86,14 +86,14 @@ def create_externals_array(): def initialise_variables(voi, states, rates, constants, algebraic, external_variable): + states[0] = 0.6 + states[1] = 0.05 + states[2] = 0.325 constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - states[0] = 0.6 - states[1] = 0.05 - states[2] = 0.325 algebraic[1] = external_variable(voi, states, rates, variables, 1) algebraic[9] = external_variable(voi, states, rates, variables, 9) algebraic[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 82b0b193e..7aaf3feb1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -78,15 +78,15 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.05 + states[3] = 0.325 constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.05 - states[3] = 0.325 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 373332828..fff1a06f0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -115,14 +115,14 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) { + states[0] = 0.0; + states[1] = 0.6; + states[2] = 0.325; constants[0] = 1.0; constants[1] = 0.0; constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - states[0] = 0.0; - states[1] = 0.6; - states[2] = 0.325; algebraic[4] = externalVariable(voi, states, rates, variables, 4); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index c13120d5c..c9fd02275 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -86,14 +86,14 @@ def create_externals_array(): def initialise_variables(voi, states, rates, constants, algebraic, external_variable): + states[0] = 0.0 + states[1] = 0.6 + states[2] = 0.325 constants[0] = 1.0 constants[1] = 0.0 constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - states[0] = 0.0 - states[1] = 0.6 - states[2] = 0.325 algebraic[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index f1ddf0593..7b978a5a7 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -99,15 +99,15 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = -87.0; + states[1] = 0.01; + states[2] = 0.8; + states[3] = 0.01; constants[0] = 12.0; constants[1] = 0.075; constants[2] = -60.0; constants[3] = 400.0; constants[4] = 40.0; - states[0] = -87.0; - states[1] = 0.01; - states[2] = 0.8; - states[3] = 0.01; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 04b15d26b..998e70942 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -65,15 +65,15 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): + states[0] = -87.0 + states[1] = 0.01 + states[2] = 0.8 + states[3] = 0.01 constants[0] = 12.0 constants[1] = 0.075 constants[2] = -60.0 constants[3] = 400.0 constants[4] = 40.0 - states[0] = -87.0 - states[1] = 0.01 - states[2] = 0.8 - states[3] = 0.01 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 60f3dd752..acf5f9b71 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -80,8 +80,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - computedConstants[0] = 1.0; states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 607d6c441..e4b0565e7 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -46,8 +46,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - computed_constants[0] = 1.0 states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index c8b417840..c1700a497 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -80,8 +80,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - computedConstants[0] = 1.0; states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 11486d4f8..aa95574b4 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -46,8 +46,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - computed_constants[0] = 1.0 states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index 3e90ce418..f201c2cb4 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -80,8 +80,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - constants[0] = 1.0; states[0] = 1.0; + constants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 95b5ade5f..17b950ef3 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -46,8 +46,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - constants[0] = 1.0 states[0] = 1.0 + constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index b5cd5dc86..19f3ea08f 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -80,8 +80,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - constants[0] = 1.0; states[0] = 1.0; + constants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 4da1db089..4179fad78 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -46,8 +46,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - constants[0] = 1.0 states[0] = 1.0 + constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index c335d5c5a..50b5e525b 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -81,9 +81,9 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - constants[0] = 1.0; states[0] = -2.0; states[1] = 0.0; + constants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index d3a7b6a53..cfe8f9dbb 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -47,9 +47,9 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - constants[0] = 1.0 states[0] = -2.0 states[1] = 0.0 + constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 57ea6044a..69cb46ef0 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -81,9 +81,9 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - constants[0] = 1.0; states[0] = -2.0; states[1] = 0.0; + constants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 28fe3ff9d..d6823483b 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -47,9 +47,9 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - constants[0] = 1.0 states[0] = -2.0 states[1] = 0.0 + constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index fe2854380..67a376b76 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -81,9 +81,9 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - constants[0] = 1.0; states[0] = 1.0; states[1] = 1.0; + constants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index c9ff7906f..3fc06a3ab 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -47,9 +47,9 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - constants[0] = 1.0 states[0] = 1.0 states[1] = 1.0 + constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index f1bdfd8f0..026a8322f 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -119,12 +119,12 @@ void findRoot0(double voi, double *states, double *rates, double *variables) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = 1.0; + states[1] = 0.0; constants[0] = 0.04; constants[1] = 1.0e4; constants[2] = 3.0e7; algebraic[0] = 0.0; - states[0] = 1.0; - states[1] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index fdf991695..ab4381389 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -75,12 +75,12 @@ def find_root_0(voi, states, rates, variables): def initialise_variables(states, rates, constants, algebraic): + states[0] = 1.0 + states[1] = 0.0 constants[0] = 0.04 constants[1] = 1.0e4 constants[2] = 3.0e7 algebraic[0] = 0.0 - states[0] = 1.0 - states[1] = 0.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index d304b17f9..6685a416a 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -85,12 +85,12 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - constants[0] = 0.04; - constants[1] = 1.0e4; - constants[2] = 3.0e7; states[0] = 1.0; states[1] = 0.0; states[2] = 0.0; + constants[0] = 0.04; + constants[1] = 1.0e4; + constants[2] = 3.0e7; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 0da019dd3..d6da1199a 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -51,12 +51,12 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - constants[0] = 0.04 - constants[1] = 1.0e4 - constants[2] = 3.0e7 states[0] = 1.0 states[1] = 0.0 states[2] = 0.0 + constants[0] = 0.04 + constants[1] = 1.0e4 + constants[2] = 3.0e7 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index afc9fc26a..1f9180682 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -89,6 +89,7 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { + states[0] = constants[0]; constants[0] = 0.0; constants[1] = 0.75; computedConstants[0] = 2.0/3.14159265358979; @@ -96,7 +97,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[2] = 3.14159265358979/2.0; computedConstants[3] = 3.14159265358979; computedConstants[4] = 3.0*3.14159265358979/2.0; - states[0] = constants[0]; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 68dbffb33..454eb6493 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -59,6 +59,7 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): + states[0] = constants[0] constants[0] = 0.0 constants[1] = 0.75 computed_constants[0] = 2.0/3.14159265358979 @@ -66,7 +67,6 @@ def initialise_variables(states, rates, constants, algebraic): computed_constants[2] = 3.14159265358979/2.0 computed_constants[3] = 3.14159265358979 computed_constants[4] = 3.0*3.14159265358979/2.0 - states[0] = constants[0] def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 778e44ef9..e230aecdb 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -80,8 +80,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { - constants[0] = 7.0; states[0] = constants[0]; + constants[0] = 7.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 4be9384a6..814cd74a7 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -46,8 +46,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): - constants[0] = 7.0 states[0] = constants[0] + constants[0] = 7.0 def compute_computed_constants(constants, computed_constants): From b1b753624b8d3565383c41820af51050286fba12 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 15 Aug 2024 16:44:42 +0200 Subject: [PATCH 26/74] Generator: initialise all computed constants in computeComputedConstants(). --- src/generator.cpp | 17 ++++++++++--- tests/resources/coverage/generator/model.c | 24 +++++++++---------- .../generator/model.implementation.out | 24 +++++++++---------- .../generator/model.modified.profile.c | 24 +++++++++---------- .../generator/model.modified.profile.py | 24 +++++++++---------- tests/resources/coverage/generator/model.out | 24 +++++++++---------- tests/resources/coverage/generator/model.py | 24 +++++++++---------- .../algebraic_eqn_computed_var_on_rhs/model.c | 2 +- .../model.py | 3 ++- .../algebraic_eqn_constant_on_rhs/model.c | 2 +- .../algebraic_eqn_constant_on_rhs/model.py | 4 ++-- .../algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 3 +-- .../model.c | 2 +- .../model.py | 3 +-- .../algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs/model.py | 3 +-- .../model.c | 2 +- .../model.py | 3 +-- .../model.c | 6 ++--- .../model.external.c | 6 ++--- .../model.external.py | 7 +++--- .../model.py | 7 +++--- .../algebraic_unknown_var_on_rhs/model.c | 2 +- .../algebraic_unknown_var_on_rhs/model.py | 3 ++- .../generator/ode_computed_var_on_rhs/model.c | 2 +- .../ode_computed_var_on_rhs/model.py | 3 +-- .../model.c | 2 +- .../model.py | 3 +-- .../generator/sine_model_imports/model.c | 8 +++---- .../generator/sine_model_imports/model.py | 7 +++--- 31 files changed, 126 insertions(+), 122 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index 0404698ab..95b8bba40 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1854,12 +1854,16 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st } } - // Initialise our true constants. + // Initialise our (initialised) true constants. + // Note: this means that we don't initialise (computed) constants that are initialised using a true constant + // through an equation (e.g., x = 3 rather than x with an initial value of 3), hence we test the number + // of constants in the equation. auto equations = mModel->equations(); for (const auto &equation : equations) { - if (equation->type() == AnalyserEquation::Type::TRUE_CONSTANT) { + if ((equation->constantCount() == 1) + && (equation->type() == AnalyserEquation::Type::TRUE_CONSTANT)) { methodBody += generateEquationCode(equation, remainingEquations); } } @@ -1889,10 +1893,17 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st void Generator::GeneratorImpl::addImplementationComputeComputedConstantsMethodCode(std::vector &remainingEquations) { if (!mProfile->implementationComputeComputedConstantsMethodString().empty()) { + // Initialise all our computed constants. + // Note: this means (computed) constants that are initialised using an equation that relies on constant + // variables (e.g., x = a + b, with a and b being constants), as well as (computed) constants that are + // initialised using a true constant through an equation (e.g., x = 3 rather than x with an initial value + // of 3). + std::string methodBody; for (const auto &equation : mModel->equations()) { - if (equation->type() == AnalyserEquation::Type::VARIABLE_BASED_CONSTANT) { + if ((equation->type() == AnalyserEquation::Type::TRUE_CONSTANT) + || (equation->type() == AnalyserEquation::Type::VARIABLE_BASED_CONSTANT)) { methodBody += generateEquationCode(equation, remainingEquations); } } diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index b6479b2b8..8ba9f8fd4 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -417,18 +417,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[6] = 7.0; algebraic[0] = 1.0; algebraic[1] = 2.0; - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -610,7 +598,17 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; computedConstants[175] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; computedConstants[176] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; computedConstants[181] = constants[0]; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; computedConstants[188] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); computedConstants[189] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); computedConstants[190] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); @@ -621,6 +619,8 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[195] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); computedConstants[196] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); computedConstants[197] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index ab220a0b3..4e3c75233 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -180,18 +180,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[6] = 7.0; algebraic[0] = 1.0; algebraic[1] = 2.0; - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -373,7 +361,17 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[174] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:NAN; computedConstants[175] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:constants[6]; computedConstants[176] = 123.0+((gt(constants[0], constants[1]))?constants[0]:NAN); + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; computedConstants[181] = constants[0]; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; computedConstants[188] = and(constants[0], constants[1])+((gt(constants[2], constants[3]))?constants[1]:NAN)+constants[4]+and(constants[5], constants[6]); computedConstants[189] = and(constants[0], constants[1])-(((gt(constants[2], constants[3]))?constants[1]:NAN)-(constants[4]-((gt(constants[2], constants[3]))?constants[1]:NAN)))-and(constants[5], constants[6]); computedConstants[190] = and(constants[0], constants[1])*((gt(constants[2], constants[3]))?constants[1]:NAN)*constants[4]*((gt(constants[2], constants[3]))?constants[1]:NAN)*and(constants[5], constants[6]); @@ -384,6 +382,8 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[195] = pow(and(constants[0], constants[1]), pow((gt(constants[2], constants[3]))?constants[1]:NAN, pow(pow(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), and(constants[0], constants[1])))); computedConstants[196] = pow(pow(pow(and(constants[0], constants[1]), 1.0/pow((gt(constants[2], constants[3]))?constants[1]:NAN, 1.0/constants[4])), 1.0/((gt(constants[2], constants[3]))?constants[1]:NAN)), 1.0/and(constants[0], constants[1])); computedConstants[197] = -and(constants[0], constants[1])+-((gt(constants[2], constants[3]))?constants[1]:NAN); + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 96320e6c0..32e5b78d5 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -417,18 +417,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[6] = 7.0; algebraic[0] = 1.0; algebraic[1] = 2.0; - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -610,7 +598,17 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; computedConstants[175] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; computedConstants[176] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; computedConstants[181] = constants[0]; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; computedConstants[188] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); computedConstants[189] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); computedConstants[190] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); @@ -621,6 +619,8 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[195] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); computedConstants[196] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); computedConstants[197] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index eea22df56..5c5e36cbd 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -394,18 +394,6 @@ def initialise_variables(states, rates, constants, algebraic): constants[6] = 7.0 algebraic[0] = 1.0 algebraic[1] = 2.0 - computed_constants[177] = 123.0 - computed_constants[178] = 123.456789 - computed_constants[179] = 123.0e99 - computed_constants[180] = 123.456789e99 - computed_constants[182] = 1.0 - computed_constants[183] = 0.0 - computed_constants[184] = 2.71828182845905 - computed_constants[185] = 3.14159265358979 - computed_constants[186] = inf - computed_constants[187] = nan - computed_constants[198] = 1.0 - computed_constants[199] = 3.0 def compute_computed_constants(constants, computed_constants): @@ -586,7 +574,17 @@ def compute_computed_constants(constants, computed_constants): computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan computed_constants[175] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] computed_constants[176] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) + computed_constants[177] = 123.0 + computed_constants[178] = 123.456789 + computed_constants[179] = 123.0e99 + computed_constants[180] = 123.456789e99 computed_constants[181] = constants[0] + computed_constants[182] = 1.0 + computed_constants[183] = 0.0 + computed_constants[184] = 2.71828182845905 + computed_constants[185] = 3.14159265358979 + computed_constants[186] = inf + computed_constants[187] = nan computed_constants[188] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) computed_constants[189] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) computed_constants[190] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) @@ -597,6 +595,8 @@ def compute_computed_constants(constants, computed_constants): computed_constants[195] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) computed_constants[196] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) computed_constants[197] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) + computed_constants[198] = 1.0 + computed_constants[199] = 3.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index 3f57e2f5c..63ed9abc2 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -128,18 +128,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[6] = 7.0; algebraic[0] = 1.0; algebraic[1] = 2.0; - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -321,7 +309,17 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[174] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], NAN))); computedConstants[175] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], constants[6]))); computedConstants[176] = 123.0+piecewise(constants[0] > constants[1], constants[0], NAN); + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; computedConstants[181] = constants[0]; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; computedConstants[188] = (constants[0] && constants[1])+piecewise(constants[2] > constants[3], constants[1], NAN)+constants[4]+(constants[5] && constants[6]); computedConstants[189] = (constants[0] && constants[1])-(piecewise(constants[2] > constants[3], constants[1], NAN)-(constants[4]-piecewise(constants[2] > constants[3], constants[1], NAN)))-(constants[5] && constants[6]); computedConstants[190] = (constants[0] && constants[1])*piecewise(constants[2] > constants[3], constants[1], NAN)*constants[4]*piecewise(constants[2] > constants[3], constants[1], NAN)*(constants[5] && constants[6]); @@ -332,6 +330,8 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[195] = (constants[0] && constants[1])^^(piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[4]^^piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[0] && constants[1]))); computedConstants[196] = (constants[0] && constants[1])^^(1.0/(piecewise(constants[2] > constants[3], constants[1], NAN)^^(1.0/constants[4])))^^(1.0/piecewise(constants[2] > constants[3], constants[1], NAN))^^(1.0/(constants[0] && constants[1])); computedConstants[197] = -(constants[0] && constants[1])+-piecewise(constants[2] > constants[3], constants[1], NAN); + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 8e305579f..b36dad8de 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -394,18 +394,6 @@ def initialise_variables(states, rates, constants, algebraic): constants[6] = 7.0 algebraic[0] = 1.0 algebraic[1] = 2.0 - computed_constants[177] = 123.0 - computed_constants[178] = 123.456789 - computed_constants[179] = 123.0e99 - computed_constants[180] = 123.456789e99 - computed_constants[182] = 1.0 - computed_constants[183] = 0.0 - computed_constants[184] = 2.71828182845905 - computed_constants[185] = 3.14159265358979 - computed_constants[186] = inf - computed_constants[187] = nan - computed_constants[198] = 1.0 - computed_constants[199] = 3.0 def compute_computed_constants(constants, computed_constants): @@ -586,7 +574,17 @@ def compute_computed_constants(constants, computed_constants): computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan computed_constants[175] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] computed_constants[176] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) + computed_constants[177] = 123.0 + computed_constants[178] = 123.456789 + computed_constants[179] = 123.0e99 + computed_constants[180] = 123.456789e99 computed_constants[181] = constants[0] + computed_constants[182] = 1.0 + computed_constants[183] = 0.0 + computed_constants[184] = 2.71828182845905 + computed_constants[185] = 3.14159265358979 + computed_constants[186] = inf + computed_constants[187] = nan computed_constants[188] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) computed_constants[189] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) computed_constants[190] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) @@ -597,6 +595,8 @@ def compute_computed_constants(constants, computed_constants): computed_constants[195] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) computed_constants[196] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) computed_constants[197] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) + computed_constants[198] = 1.0 + computed_constants[199] = 3.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index a3c00b62d..77864fe75 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -63,12 +63,12 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic) { - computedConstants[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { computedConstants[0] = computedConstants[1]; + computedConstants[1] = 1.0; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index e16ebcdbb..7478720bd 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -36,11 +36,12 @@ def create_algebraic_array(): def initialise_variables(constants, algebraic): - computed_constants[1] = 1.0 + pass def compute_computed_constants(constants, computed_constants): computed_constants[0] = computed_constants[1] + computed_constants[1] = 1.0 def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index f4791714a..44c462e66 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -62,11 +62,11 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic) { - computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { + computedConstants[0] = 1.0; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index af04c489b..ec6d22f69 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -35,11 +35,11 @@ def create_algebraic_array(): def initialise_variables(constants, algebraic): - computed_constants[0] = 1.0 + pass def compute_computed_constants(constants, computed_constants): - pass + computed_constants[0] = 1.0 def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 346113323..8050184e0 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -82,11 +82,11 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; - computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { + computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 4c38d6136..0da204aec 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -48,11 +48,10 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): states[0] = 1.0 - computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - pass + computed_constants[0] = 1.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index b986dc276..37466c281 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -82,11 +82,11 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; - computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { + computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 45d1c49bf..ffb5d2a00 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -48,11 +48,10 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): states[0] = 1.0 - computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - pass + computed_constants[0] = 1.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 2435f13f6..9c9f2695d 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -82,11 +82,11 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; - computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { + computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 3f9078205..1c3a92bcd 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -48,11 +48,10 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): states[0] = 1.0 - computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - pass + computed_constants[0] = 1.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 1c1013f49..f8e0f2101 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -82,11 +82,11 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; - computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { + computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 921b10db4..e1d0ff117 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -48,11 +48,10 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): states[0] = 1.0 - computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - pass + computed_constants[0] = 1.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 105a0833d..f197a0f5d 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -94,13 +94,13 @@ void findRoot0(double *variables) void initialiseVariables(double *constants, double *algebraic) { algebraic[0] = 1.0; - computedConstants[0] = 3.0; - computedConstants[1] = 5.0; - computedConstants[2] = 7.0; } void computeComputedConstants(double *constants, double *computedConstants) { + computedConstants[0] = 3.0; + computedConstants[1] = 5.0; + computedConstants[2] = 7.0; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index d38d0c08e..e6176a519 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -80,14 +80,14 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) { - computedConstants[0] = 3.0; - computedConstants[1] = 5.0; - computedConstants[2] = 7.0; algebraic[0] = externalVariable(variables, 0); } void computeComputedConstants(double *constants, double *computedConstants) { + computedConstants[0] = 3.0; + computedConstants[1] = 5.0; + computedConstants[2] = 7.0; } void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 15e43a6c7..a3b14cd85 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -46,14 +46,13 @@ def create_externals_array(): def initialise_variables(constants, algebraic, external_variable): - computed_constants[0] = 3.0 - computed_constants[1] = 5.0 - computed_constants[2] = 7.0 algebraic[0] = external_variable(variables, 0) def compute_computed_constants(constants, computed_constants): - pass + computed_constants[0] = 3.0 + computed_constants[1] = 5.0 + computed_constants[2] = 7.0 def compute_variables(constants, computed_constants, algebraic, external_variable): diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index df36f9d08..d0b04d108 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -60,13 +60,12 @@ def find_root_0(variables): def initialise_variables(constants, algebraic): algebraic[0] = 1.0 - computed_constants[0] = 3.0 - computed_constants[1] = 5.0 - computed_constants[2] = 7.0 def compute_computed_constants(constants, computed_constants): - pass + computed_constants[0] = 3.0 + computed_constants[1] = 5.0 + computed_constants[2] = 7.0 def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index 48c8e8533..dc329bd29 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -63,11 +63,11 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic) { - computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { + computedConstants[0] = 1.0; computedConstants[1] = computedConstants[0]; } diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 34185c7ef..56ec81b7e 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -36,10 +36,11 @@ def create_algebraic_array(): def initialise_variables(constants, algebraic): - computed_constants[0] = 1.0 + pass def compute_computed_constants(constants, computed_constants): + computed_constants[0] = 1.0 computed_constants[1] = computed_constants[0] diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index acf5f9b71..fb2e5ed24 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -81,11 +81,11 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; - computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { + computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index e4b0565e7..4d2a9c43c 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -47,11 +47,10 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): states[0] = 1.0 - computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - pass + computed_constants[0] = 1.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index c1700a497..8c03c4af6 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -81,11 +81,11 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; - computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { + computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index aa95574b4..b475ed2af 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -47,11 +47,10 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, algebraic): states[0] = 1.0 - computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - pass + computed_constants[0] = 1.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 1f9180682..b25348318 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -92,6 +92,10 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl states[0] = constants[0]; constants[0] = 0.0; constants[1] = 0.75; +} + +void computeComputedConstants(double *constants, double *computedConstants) +{ computedConstants[0] = 2.0/3.14159265358979; computedConstants[1] = 2.0*3.14159265358979; computedConstants[2] = 3.14159265358979/2.0; @@ -99,10 +103,6 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[4] = 3.0*3.14159265358979/2.0; } -void computeComputedConstants(double *constants, double *computedConstants) -{ -} - void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = cos(voi); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 454eb6493..35bb474ab 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -62,6 +62,9 @@ def initialise_variables(states, rates, constants, algebraic): states[0] = constants[0] constants[0] = 0.0 constants[1] = 0.75 + + +def compute_computed_constants(constants, computed_constants): computed_constants[0] = 2.0/3.14159265358979 computed_constants[1] = 2.0*3.14159265358979 computed_constants[2] = 3.14159265358979/2.0 @@ -69,10 +72,6 @@ def initialise_variables(states, rates, constants, algebraic): computed_constants[4] = 3.0*3.14159265358979/2.0 -def compute_computed_constants(constants, computed_constants): - pass - - def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = cos(voi) From a46dbca50366735b5f130e5693d6c2bfd5771610 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 16 Aug 2024 10:13:22 +0200 Subject: [PATCH 27/74] GeneratorProfile: added the external array string. --- src/api/libcellml/generatorprofile.h | 19 +++++++++++ src/bindings/interface/generatorprofile.i | 6 ++++ src/bindings/javascript/generatorprofile.cpp | 2 ++ src/generator.cpp | 16 +++++++--- src/generatorprofile.cpp | 12 +++++++ src/generatorprofile_p.h | 1 + src/generatorprofilesha1values.h | 4 +-- src/generatorprofiletools.cpp | 3 +- tests/bindings/javascript/generator.test.js | 2 +- .../javascript/generatorprofile.test.js | 6 ++++ .../bindings/python/test_generator_profile.py | 9 ++++++ tests/generator/generatorprofile.cpp | 3 ++ .../model.external.c | 6 ++-- .../model.external.py | 6 ++-- .../model.external.c | 4 +-- .../model.external.py | 4 +-- .../model.three.externals.c | 12 +++---- .../model.three.externals.py | 12 +++---- .../cell_geometry_model/model.external.c | 10 +++--- .../cell_geometry_model/model.external.py | 10 +++--- .../model.algebraic.c | 8 ++--- .../model.algebraic.py | 8 ++--- .../model.computed.constant.c | 10 +++--- .../model.computed.constant.py | 10 +++--- .../model.constant.c | 8 ++--- .../model.constant.py | 8 ++--- .../model.dae.c | 12 +++---- .../model.dae.py | 12 +++---- .../model.dependent.algebraic.c | 16 +++++----- .../model.dependent.algebraic.py | 16 +++++----- .../model.dependent.computed.constant.c | 24 +++++++------- .../model.dependent.computed.constant.py | 24 +++++++------- .../model.dependent.constant.c | 18 +++++------ .../model.dependent.constant.py | 18 +++++------ .../model.dependent.state.c | 28 ++++++++-------- .../model.dependent.state.py | 28 ++++++++-------- .../model.external.c | 32 +++++++++---------- .../model.external.py | 32 +++++++++---------- .../model.state.c | 10 +++--- .../model.state.py | 10 +++--- .../model.c | 6 ++-- .../model.py | 6 ++-- 42 files changed, 279 insertions(+), 212 deletions(-) diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index 943eca801..ae367e295 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -3122,6 +3122,25 @@ class LIBCELLML_EXPORT GeneratorProfile */ void setAlgebraicArrayString(const std::string &algebraicArrayString); + /** + * @brief Get the @c std::string for the name of the external array. + * + * Return the @c std::string for the name of the external array. + * + * @return The @c std::string for the name of the external array. + */ + std::string externalArrayString() const; + + /** + * @brief Set the @c std::string for the name of the external array. + * + * Set the @c std::string for the name of the external array. + * + * @param externalArrayString The @c std::string to use for the name of the + * external array. + */ + void setExternalArrayString(const std::string &externalArrayString); + /** * @brief Get the @c std::string for the type definition of an external * variable method. diff --git a/src/bindings/interface/generatorprofile.i b/src/bindings/interface/generatorprofile.i index 23fc7a9b9..426cd08a2 100644 --- a/src/bindings/interface/generatorprofile.i +++ b/src/bindings/interface/generatorprofile.i @@ -860,6 +860,12 @@ and units of a variable respectively."; %feature("docstring") libcellml::GeneratorProfile::setAlgebraicArrayString "Sets the string for the name of the algebraic array."; +%feature("docstring") libcellml::GeneratorProfile::externalArrayString +"Returns the string for the name of the external array."; + +%feature("docstring") libcellml::GeneratorProfile::setExternalArrayString +"Sets the string for the name of the external array."; + %feature("docstring") libcellml::GeneratorProfile::externalVariableMethodTypeDefinitionString "Returns the string for the type definition of an external variable method."; diff --git a/src/bindings/javascript/generatorprofile.cpp b/src/bindings/javascript/generatorprofile.cpp index 1f4d57997..e981e701e 100644 --- a/src/bindings/javascript/generatorprofile.cpp +++ b/src/bindings/javascript/generatorprofile.cpp @@ -307,6 +307,8 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setComputedConstantsArrayString", &libcellml::GeneratorProfile::setComputedConstantsArrayString) .function("algebraicArrayString", &libcellml::GeneratorProfile::algebraicArrayString) .function("setAlgebraicArrayString", &libcellml::GeneratorProfile::setAlgebraicArrayString) + .function("externalArrayString", &libcellml::GeneratorProfile::externalArrayString) + .function("setExternalArrayString", &libcellml::GeneratorProfile::setExternalArrayString) .function("externalVariableMethodTypeDefinitionString", &libcellml::GeneratorProfile::externalVariableMethodTypeDefinitionString) .function("setExternalVariableMethodTypeDefinitionString", &libcellml::GeneratorProfile::setExternalVariableMethodTypeDefinitionString) .function("externalVariableMethodCallString", &libcellml::GeneratorProfile::externalVariableMethodCallString) diff --git a/src/generator.cpp b/src/generator.cpp index 95b8bba40..ce6cc531f 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -764,7 +764,9 @@ void Generator::GeneratorImpl::addNlaSystemsCode() mProfile->constantsArrayString() : (variable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) ? mProfile->computedConstantsArrayString() : - mProfile->algebraicArrayString(); + (variable->type() == AnalyserVariable::Type::ALGEBRAIC) ? + mProfile->algebraicArrayString() : + mProfile->externalArrayString(); methodBody += mProfile->indentString() + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() @@ -807,7 +809,9 @@ void Generator::GeneratorImpl::addNlaSystemsCode() for (const auto &variable : variables) { auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - mProfile->algebraicArrayString(); + (variable->type() == AnalyserVariable::Type::ALGEBRAIC) ? + mProfile->algebraicArrayString() : + mProfile->externalArrayString(); methodBody += mProfile->indentString() + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() @@ -831,7 +835,9 @@ void Generator::GeneratorImpl::addNlaSystemsCode() for (const auto &variable : variables) { auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - mProfile->algebraicArrayString(); + (variable->type() == AnalyserVariable::Type::ALGEBRAIC) ? + mProfile->algebraicArrayString() : + mProfile->externalArrayString(); methodBody += mProfile->indentString() + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() @@ -914,8 +920,10 @@ std::string Generator::GeneratorImpl::generateVariableNameCode(const VariablePtr arrayName = mProfile->constantsArrayString(); } else if (analyserVariable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) { arrayName = mProfile->computedConstantsArrayString(); - } else { + } else if (analyserVariable->type() == AnalyserVariable::Type::ALGEBRAIC) { arrayName = mProfile->algebraicArrayString(); + } else { + arrayName = mProfile->externalArrayString(); } return arrayName + mProfile->openArrayString() + convertToString(analyserVariable->index()) + mProfile->closeArrayString(); diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 997fa4bfb..bc191920b 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -288,6 +288,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mConstantsArrayString = "constants"; mComputedConstantsArrayString = "computedConstants"; mAlgebraicArrayString = "algebraic"; + mExternalArrayString = "external"; mExternalVariableMethodTypeDefinitionFamString = "typedef double (* ExternalVariable)(double *variables, size_t index);\n"; mExternalVariableMethodTypeDefinitionFdmString = "typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index);\n"; @@ -740,6 +741,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mConstantsArrayString = "constants"; mComputedConstantsArrayString = "computed_constants"; mAlgebraicArrayString = "algebraic"; + mExternalArrayString = "external"; mExternalVariableMethodTypeDefinitionFamString = ""; mExternalVariableMethodTypeDefinitionFdmString = ""; @@ -2288,6 +2290,16 @@ void GeneratorProfile::setAlgebraicArrayString(const std::string &algebraicArray mPimpl->mAlgebraicArrayString = algebraicArrayString; } +std::string GeneratorProfile::externalArrayString() const +{ + return mPimpl->mExternalArrayString; +} + +void GeneratorProfile::setExternalArrayString(const std::string &externalArrayString) +{ + mPimpl->mExternalArrayString = externalArrayString; +} + std::string GeneratorProfile::externalVariableMethodTypeDefinitionString(bool forDifferentialModel) const { if (forDifferentialModel) { diff --git a/src/generatorprofile_p.h b/src/generatorprofile_p.h index 286edca8e..167f8ab23 100644 --- a/src/generatorprofile_p.h +++ b/src/generatorprofile_p.h @@ -217,6 +217,7 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mConstantsArrayString; std::string mComputedConstantsArrayString; std::string mAlgebraicArrayString; + std::string mExternalArrayString; std::string mExternalVariableMethodTypeDefinitionFamString; std::string mExternalVariableMethodTypeDefinitionFdmString; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index cf522db03..c96cffaf2 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "2d4d14df0a454d95e32e1172503d529834c42588"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "5ff1e7cc237b3e7eb1153b6d421df842731c6394"; +static const char C_GENERATOR_PROFILE_SHA1[] = "54ee603459d7878ee469890e77de4f3dbb5452ad"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "bf42c06955e401096d76d059a28ed1a5cb1ccc01"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index d74e462be..5fa609392 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -482,7 +482,8 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile + generatorProfile->ratesArrayString() + generatorProfile->constantsArrayString() + generatorProfile->computedConstantsArrayString() - + generatorProfile->algebraicArrayString(); + + generatorProfile->algebraicArrayString() + + generatorProfile->externalArrayString(); profileContents += generatorProfile->externalVariableMethodTypeDefinitionString(false) + generatorProfile->externalVariableMethodTypeDefinitionString(true); diff --git a/tests/bindings/javascript/generator.test.js b/tests/bindings/javascript/generator.test.js index b5860fd01..802b47941 100644 --- a/tests/bindings/javascript/generator.test.js +++ b/tests/bindings/javascript/generator.test.js @@ -62,7 +62,7 @@ describe("Generator tests", () => { g.setModel(a.model()) const interface_lines = g.interfaceCode().split('\n') - expect(interface_lines.length).toBe(37) + expect(interface_lines.length).toBe(38) const implementation_lines = g.implementationCode().split('\n') expect(implementation_lines.length).toBe(97) diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index 81b1b13ff..e1f63eee4 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -915,6 +915,12 @@ describe("GeneratorProfile tests", () => { x.setAlgebraicArrayString("something") expect(x.algebraicArrayString()).toBe("something") }); + test("Checking GeneratorProfile.externalArrayString.", () => { + const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) + + x.setExternalArrayString("something") + expect(x.externalArrayString()).toBe("something") + }); test("Checking GeneratorProfile.externalVariableMethodTypeDefinitionString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 7c97f547d..51d67a723 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -1682,6 +1682,15 @@ def test_algebraic_array_string(self): g.setAlgebraicArrayString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.algebraicArrayString()) + def test_external_array_string(self): + from libcellml import GeneratorProfile + + g = GeneratorProfile() + + self.assertEqual('external', g.externalArrayString()) + g.setExternalArrayString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalArrayString()) + def test_external_variable_method_type_definition_string(self): from libcellml import GeneratorProfile diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 1e8b33b53..aa91c910a 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -340,6 +340,7 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("constants", generatorProfile->constantsArrayString()); EXPECT_EQ("computedConstants", generatorProfile->computedConstantsArrayString()); EXPECT_EQ("algebraic", generatorProfile->algebraicArrayString()); + EXPECT_EQ("external", generatorProfile->externalArrayString()); EXPECT_EQ("typedef double (* ExternalVariable)(double *variables, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(false)); EXPECT_EQ("typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(true)); @@ -938,6 +939,7 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setConstantsArrayString(value); generatorProfile->setComputedConstantsArrayString(value); generatorProfile->setAlgebraicArrayString(value); + generatorProfile->setExternalArrayString(value); generatorProfile->setExternalVariableMethodTypeDefinitionString(false, value); generatorProfile->setExternalVariableMethodTypeDefinitionString(true, value); @@ -1084,6 +1086,7 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->constantsArrayString()); EXPECT_EQ(value, generatorProfile->computedConstantsArrayString()); EXPECT_EQ(value, generatorProfile->algebraicArrayString()); + EXPECT_EQ(value, generatorProfile->externalArrayString()); EXPECT_EQ(value, generatorProfile->externalVariableMethodTypeDefinitionString(false)); EXPECT_EQ(value, generatorProfile->externalVariableMethodTypeDefinitionString(true)); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 06d47e8fe..9dc593142 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -78,7 +78,7 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) { - algebraic[1] = externalVariable(variables, 1); + external[1] = externalVariable(variables, 1); } void computeComputedConstants(double *constants, double *computedConstants) @@ -87,6 +87,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[1] = externalVariable(variables, 1); - algebraic[0] = algebraic[1]; + external[1] = externalVariable(variables, 1); + algebraic[0] = external[1]; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 94691a7c9..56bde48d8 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -44,7 +44,7 @@ def create_externals_array(): def initialise_variables(constants, algebraic, external_variable): - algebraic[1] = external_variable(variables, 1) + external[1] = external_variable(variables, 1) def compute_computed_constants(constants, computed_constants): @@ -52,5 +52,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - algebraic[1] = external_variable(variables, 1) - algebraic[0] = algebraic[1] + external[1] = external_variable(variables, 1) + algebraic[0] = external[1] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index e6176a519..fcf0650ff 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -80,7 +80,7 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) { - algebraic[0] = externalVariable(variables, 0); + external[0] = externalVariable(variables, 0); } void computeComputedConstants(double *constants, double *computedConstants) @@ -92,5 +92,5 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[0] = externalVariable(variables, 0); + external[0] = externalVariable(variables, 0); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index a3b14cd85..c55a3656b 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -46,7 +46,7 @@ def create_externals_array(): def initialise_variables(constants, algebraic, external_variable): - algebraic[0] = external_variable(variables, 0) + external[0] = external_variable(variables, 0) def compute_computed_constants(constants, computed_constants): @@ -56,4 +56,4 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - algebraic[0] = external_variable(variables, 0) + external[0] = external_variable(variables, 0) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index 14f3025e2..1a1de087c 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -79,9 +79,9 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) { - algebraic[0] = externalVariable(variables, 0); - algebraic[1] = externalVariable(variables, 1); - algebraic[2] = externalVariable(variables, 2); + external[0] = externalVariable(variables, 0); + external[1] = externalVariable(variables, 1); + external[2] = externalVariable(variables, 2); } void computeComputedConstants(double *constants, double *computedConstants) @@ -90,7 +90,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[0] = externalVariable(variables, 0); - algebraic[1] = externalVariable(variables, 1); - algebraic[2] = externalVariable(variables, 2); + external[0] = externalVariable(variables, 0); + external[1] = externalVariable(variables, 1); + external[2] = externalVariable(variables, 2); } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index b7f5d99b6..f83da06d0 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -45,9 +45,9 @@ def create_externals_array(): def initialise_variables(constants, algebraic, external_variable): - algebraic[0] = external_variable(variables, 0) - algebraic[1] = external_variable(variables, 1) - algebraic[2] = external_variable(variables, 2) + external[0] = external_variable(variables, 0) + external[1] = external_variable(variables, 1) + external[2] = external_variable(variables, 2) def compute_computed_constants(constants, computed_constants): @@ -55,6 +55,6 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - algebraic[0] = external_variable(variables, 0) - algebraic[1] = external_variable(variables, 1) - algebraic[2] = external_variable(variables, 2) + external[0] = external_variable(variables, 0) + external[1] = external_variable(variables, 1) + external[2] = external_variable(variables, 2) diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index daa7e0447..9443a6222 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -80,8 +80,8 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) { - algebraic[1] = externalVariable(variables, 1); - algebraic[2] = externalVariable(variables, 2); + external[1] = externalVariable(variables, 1); + external[2] = externalVariable(variables, 2); } void computeComputedConstants(double *constants, double *computedConstants) @@ -90,8 +90,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[1] = externalVariable(variables, 1); - algebraic[2] = externalVariable(variables, 2); - algebraic[0] = 1000.0*3.14*algebraic[2]*algebraic[2]*algebraic[1]; + external[1] = externalVariable(variables, 1); + external[2] = externalVariable(variables, 2); + algebraic[0] = 1000.0*3.14*external[2]*external[2]*external[1]; algebraic[3] = 0.02*algebraic[0]; } diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 3d16a465a..5549575c3 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -46,8 +46,8 @@ def create_externals_array(): def initialise_variables(constants, algebraic, external_variable): - algebraic[1] = external_variable(variables, 1) - algebraic[2] = external_variable(variables, 2) + external[1] = external_variable(variables, 1) + external[2] = external_variable(variables, 2) def compute_computed_constants(constants, computed_constants): @@ -55,7 +55,7 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - algebraic[1] = external_variable(variables, 1) - algebraic[2] = external_variable(variables, 2) - algebraic[0] = 1000.0*3.14*algebraic[2]*algebraic[2]*algebraic[1] + external[1] = external_variable(variables, 1) + external[2] = external_variable(variables, 2) + algebraic[0] = 1000.0*3.14*external[2]*external[2]*external[1] algebraic[3] = 0.02*algebraic[0] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 79638165e..e0dcf3cb1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -124,7 +124,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - algebraic[0] = externalVariable(voi, states, rates, variables, 0); + external[0] = externalVariable(voi, states, rates, variables, 0); } void computeComputedConstants(double *constants, double *computedConstants) @@ -136,11 +136,11 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[0] = externalVariable(voi, states, rates, variables, 0); + external[0] = externalVariable(voi, states, rates, variables, 0); algebraic[1] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; + rates[0] = -(-external[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; @@ -154,7 +154,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[0] = externalVariable(voi, states, rates, variables, 0); + external[0] = externalVariable(voi, states, rates, variables, 0); algebraic[1] = constants[2]*(states[0]-computedConstants[0]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 9d302d251..264db7750 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -95,7 +95,7 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - algebraic[0] = external_variable(voi, states, rates, variables, 0) + external[0] = external_variable(voi, states, rates, variables, 0) def compute_computed_constants(constants, computed_constants): @@ -105,11 +105,11 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[0] = external_variable(voi, states, rates, variables, 0) + external[0] = external_variable(voi, states, rates, variables, 0) algebraic[1] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] + rates[0] = -(-external[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] @@ -122,7 +122,7 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[0] = external_variable(voi, states, rates, variables, 0) + external[0] = external_variable(voi, states, rates, variables, 0) algebraic[1] = constants[2]*(states[0]-computed_constants[0]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 30d273c85..f5534292a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -124,7 +124,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - algebraic[4] = externalVariable(voi, states, rates, variables, 4); + external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) @@ -136,8 +136,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[1] = constants[2]*(states[0]-algebraic[4]); + external[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[1] = constants[2]*(states[0]-external[4]); algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; @@ -154,8 +154,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[1] = constants[2]*(states[0]-algebraic[4]); + external[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[1] = constants[2]*(states[0]-external[4]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[6] = 4.0*exp(states[0]/18.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 110c67f6c..825c30cc9 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -95,7 +95,7 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - algebraic[4] = external_variable(voi, states, rates, variables, 4) + external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): @@ -105,8 +105,8 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[4] = external_variable(voi, states, rates, variables, 4) - algebraic[1] = constants[2]*(states[0]-algebraic[4]) + external[4] = external_variable(voi, states, rates, variables, 4) + algebraic[1] = constants[2]*(states[0]-external[4]) algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] @@ -122,8 +122,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[4] = external_variable(voi, states, rates, variables, 4) - algebraic[1] = constants[2]*(states[0]-algebraic[4]) + external[4] = external_variable(voi, states, rates, variables, 4) + algebraic[1] = constants[2]*(states[0]-external[4]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[6] = 4.0*exp(states[0]/18.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index e006edcb5..7d3412568 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -123,7 +123,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[1] = 0.3; constants[2] = 120.0; constants[3] = 36.0; - algebraic[4] = externalVariable(voi, states, rates, variables, 4); + external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) @@ -136,11 +136,11 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[4] = externalVariable(voi, states, rates, variables, 4); + external[4] = externalVariable(voi, states, rates, variables, 4); algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4]; + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[4]; algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[6] = 4.0*exp(states[0]/18.0); rates[2] = algebraic[5]*(1.0-states[2])-algebraic[6]*states[2]; @@ -163,5 +163,5 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[10] = 0.125*exp(states[0]/80.0); - algebraic[4] = externalVariable(voi, states, rates, variables, 4); + external[4] = externalVariable(voi, states, rates, variables, 4); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 95ab1649b..32d9a44ba 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -94,7 +94,7 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[1] = 0.3 constants[2] = 120.0 constants[3] = 36.0 - algebraic[4] = external_variable(voi, states, rates, variables, 4) + external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): @@ -105,11 +105,11 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[4] = external_variable(voi, states, rates, variables, 4) + external[4] = external_variable(voi, states, rates, variables, 4) algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4] + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[4] algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[6] = 4.0*exp(states[0]/18.0) rates[2] = algebraic[5]*(1.0-states[2])-algebraic[6]*states[2] @@ -131,4 +131,4 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[10] = 0.125*exp(states[0]/80.0) - algebraic[4] = external_variable(voi, states, rates, variables, 4) + external[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 0e805880e..f929e387f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -173,11 +173,11 @@ void findRoot2(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[0]; + u[0] = external[0]; nlaSolve(objectiveFunction2, u, 1, &rfi); - algebraic[0] = u[0]; + external[0] = u[0]; } void objectiveFunction3(double *u, double *f, void *data) @@ -221,11 +221,11 @@ void findRoot4(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[1]; + u[0] = external[1]; nlaSolve(objectiveFunction4, u, 1, &rfi); - algebraic[1] = u[0]; + external[1] = u[0]; } void objectiveFunction5(double *u, double *f, void *data) @@ -413,11 +413,11 @@ void findRoot12(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[2]; + u[0] = external[2]; nlaSolve(objectiveFunction12, u, 1, &rfi); - algebraic[2] = u[0]; + external[2] = u[0]; } void objectiveFunction13(double *u, double *f, void *data) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index d42b47c11..4dc671937 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -136,11 +136,11 @@ def objective_function_2(u, f, data): def find_root_2(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[0] + u[0] = external[0] u = nla_solve(objective_function_2, u, 1, [voi, states, rates, variables]) - algebraic[0] = u[0] + external[0] = u[0] def objective_function_3(u, f, data): @@ -178,11 +178,11 @@ def objective_function_4(u, f, data): def find_root_4(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[1] + u[0] = external[1] u = nla_solve(objective_function_4, u, 1, [voi, states, rates, variables]) - algebraic[1] = u[0] + external[1] = u[0] def objective_function_5(u, f, data): @@ -346,11 +346,11 @@ def objective_function_12(u, f, data): def find_root_12(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[2] + u[0] = external[2] u = nla_solve(objective_function_12, u, 1, [voi, states, rates, variables]) - algebraic[2] = u[0] + external[2] = u[0] def objective_function_13(u, f, data): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index c2349a909..b91929dbd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -124,8 +124,8 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - algebraic[9] = externalVariable(voi, states, rates, variables, 9); - algebraic[0] = externalVariable(voi, states, rates, variables, 0); + external[9] = externalVariable(voi, states, rates, variables, 9); + external[0] = externalVariable(voi, states, rates, variables, 0); } void computeComputedConstants(double *constants, double *computedConstants) @@ -137,12 +137,12 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[9] = externalVariable(voi, states, rates, variables, 9); - algebraic[0] = externalVariable(voi, states, rates, variables, 0); + external[9] = externalVariable(voi, states, rates, variables, 9); + external[0] = externalVariable(voi, states, rates, variables, 0); algebraic[1] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; + rates[0] = -(-external[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; @@ -150,13 +150,13 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; + rates[3] = algebraic[8]*(1.0-states[3])-external[9]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[9] = externalVariable(voi, states, rates, variables, 9); - algebraic[0] = externalVariable(voi, states, rates, variables, 0); + external[9] = externalVariable(voi, states, rates, variables, 9); + external[0] = externalVariable(voi, states, rates, variables, 0); algebraic[1] = constants[2]*(states[0]-computedConstants[0]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index a7da90472..243b736f0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -95,8 +95,8 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - algebraic[9] = external_variable(voi, states, rates, variables, 9) - algebraic[0] = external_variable(voi, states, rates, variables, 0) + external[9] = external_variable(voi, states, rates, variables, 9) + external[0] = external_variable(voi, states, rates, variables, 0) def compute_computed_constants(constants, computed_constants): @@ -106,12 +106,12 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[9] = external_variable(voi, states, rates, variables, 9) - algebraic[0] = external_variable(voi, states, rates, variables, 0) + external[9] = external_variable(voi, states, rates, variables, 9) + external[0] = external_variable(voi, states, rates, variables, 0) algebraic[1] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] + rates[0] = -(-external[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] @@ -119,12 +119,12 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] + rates[3] = algebraic[8]*(1.0-states[3])-external[9]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[9] = external_variable(voi, states, rates, variables, 9) - algebraic[0] = external_variable(voi, states, rates, variables, 0) + external[9] = external_variable(voi, states, rates, variables, 9) + external[0] = external_variable(voi, states, rates, variables, 0) algebraic[1] = constants[2]*(states[0]-computed_constants[0]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 9ae267b45..35de38cb5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -123,8 +123,8 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[1] = 0.3; constants[2] = 120.0; constants[3] = 36.0; - algebraic[11] = externalVariable(voi, states, rates, variables, 11); - algebraic[4] = externalVariable(voi, states, rates, variables, 4); + external[11] = externalVariable(voi, states, rates, variables, 11); + external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) @@ -134,12 +134,12 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[11] = externalVariable(voi, states, rates, variables, 11); - algebraic[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[5] = algebraic[4]-10.613; + external[11] = externalVariable(voi, states, rates, variables, 11); + external[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[5] = external[4]-10.613; algebraic[1] = constants[1]*(states[0]-algebraic[5]); - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-algebraic[11]); - algebraic[6] = algebraic[4]-115.0; + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[11]); + algebraic[6] = external[4]-115.0; algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); @@ -155,17 +155,17 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[11] = externalVariable(voi, states, rates, variables, 11); - algebraic[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[5] = algebraic[4]-10.613; + external[11] = externalVariable(voi, states, rates, variables, 11); + external[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[5] = external[4]-10.613; algebraic[1] = constants[1]*(states[0]-algebraic[5]); - algebraic[6] = algebraic[4]-115.0; + algebraic[6] = external[4]-115.0; algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]); algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[8] = 4.0*exp(states[0]/18.0); algebraic[9] = 0.07*exp(states[0]/20.0); algebraic[10] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-algebraic[11]); + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[11]); algebraic[12] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[13] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 8ecf9444b..0da4974b2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -94,8 +94,8 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[1] = 0.3 constants[2] = 120.0 constants[3] = 36.0 - algebraic[11] = external_variable(voi, states, rates, variables, 11) - algebraic[4] = external_variable(voi, states, rates, variables, 4) + external[11] = external_variable(voi, states, rates, variables, 11) + external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): @@ -104,12 +104,12 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[11] = external_variable(voi, states, rates, variables, 11) - algebraic[4] = external_variable(voi, states, rates, variables, 4) - algebraic[5] = algebraic[4]-10.613 + external[11] = external_variable(voi, states, rates, variables, 11) + external[4] = external_variable(voi, states, rates, variables, 4) + algebraic[5] = external[4]-10.613 algebraic[1] = constants[1]*(states[0]-algebraic[5]) - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-algebraic[11]) - algebraic[6] = algebraic[4]-115.0 + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[11]) + algebraic[6] = external[4]-115.0 algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) @@ -124,16 +124,16 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[11] = external_variable(voi, states, rates, variables, 11) - algebraic[4] = external_variable(voi, states, rates, variables, 4) - algebraic[5] = algebraic[4]-10.613 + external[11] = external_variable(voi, states, rates, variables, 11) + external[4] = external_variable(voi, states, rates, variables, 4) + algebraic[5] = external[4]-10.613 algebraic[1] = constants[1]*(states[0]-algebraic[5]) - algebraic[6] = algebraic[4]-115.0 + algebraic[6] = external[4]-115.0 algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]) algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[8] = 4.0*exp(states[0]/18.0) algebraic[9] = 0.07*exp(states[0]/20.0) algebraic[10] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-algebraic[11]) + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[11]) algebraic[12] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[13] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 7e6747363..cc74be6ce 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -122,8 +122,8 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[0] = 0.0; constants[1] = 0.3; constants[2] = 36.0; - algebraic[5] = externalVariable(voi, states, rates, variables, 5); - algebraic[4] = externalVariable(voi, states, rates, variables, 4); + external[5] = externalVariable(voi, states, rates, variables, 5); + external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) @@ -136,12 +136,12 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[5] = externalVariable(voi, states, rates, variables, 5); - algebraic[4] = externalVariable(voi, states, rates, variables, 4); + external[5] = externalVariable(voi, states, rates, variables, 5); + external[4] = externalVariable(voi, states, rates, variables, 4); algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[3] = algebraic[5]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4]; + algebraic[3] = external[5]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[4]; algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[7] = 4.0*exp(states[0]/18.0); rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2]; @@ -156,8 +156,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = constants[1]*(states[0]-computedConstants[0]); - algebraic[5] = externalVariable(voi, states, rates, variables, 5); - algebraic[3] = algebraic[5]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + external[5] = externalVariable(voi, states, rates, variables, 5); + algebraic[3] = external[5]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[7] = 4.0*exp(states[0]/18.0); algebraic[8] = 0.07*exp(states[0]/20.0); @@ -165,5 +165,5 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[11] = 0.125*exp(states[0]/80.0); - algebraic[4] = externalVariable(voi, states, rates, variables, 4); + external[4] = externalVariable(voi, states, rates, variables, 4); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 64f4a8c1f..9ffe1b12a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -93,8 +93,8 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[0] = 0.0 constants[1] = 0.3 constants[2] = 36.0 - algebraic[5] = external_variable(voi, states, rates, variables, 5) - algebraic[4] = external_variable(voi, states, rates, variables, 4) + external[5] = external_variable(voi, states, rates, variables, 5) + external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): @@ -105,12 +105,12 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[5] = external_variable(voi, states, rates, variables, 5) - algebraic[4] = external_variable(voi, states, rates, variables, 4) + external[5] = external_variable(voi, states, rates, variables, 5) + external[4] = external_variable(voi, states, rates, variables, 4) algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[3] = algebraic[5]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/algebraic[4] + algebraic[3] = external[5]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[4] algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[7] = 4.0*exp(states[0]/18.0) rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2] @@ -124,8 +124,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[1] = constants[1]*(states[0]-computed_constants[0]) - algebraic[5] = external_variable(voi, states, rates, variables, 5) - algebraic[3] = algebraic[5]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + external[5] = external_variable(voi, states, rates, variables, 5) + algebraic[3] = external[5]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[7] = 4.0*exp(states[0]/18.0) algebraic[8] = 0.07*exp(states[0]/20.0) @@ -133,4 +133,4 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[11] = 0.125*exp(states[0]/80.0) - algebraic[4] = external_variable(voi, states, rates, variables, 4) + external[4] = external_variable(voi, states, rates, variables, 4) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 7d42c647f..3f7fde086 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -122,8 +122,8 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[5] = externalVariable(voi, states, rates, variables, 5); + external[1] = externalVariable(voi, states, rates, variables, 1); + external[5] = externalVariable(voi, states, rates, variables, 5); } void computeComputedConstants(double *constants, double *computedConstants) @@ -135,23 +135,23 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[8] = 0.07*exp(algebraic[1]/20.0); - algebraic[9] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0); + external[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[8] = 0.07*exp(external[1]/20.0); + algebraic[9] = 1.0/(exp((external[1]+30.0)/10.0)+1.0); rates[0] = algebraic[8]*(1.0-states[0])-algebraic[9]*states[0]; - algebraic[10] = 0.01*(algebraic[1]+10.0)/(exp((algebraic[1]+10.0)/10.0)-1.0); - algebraic[11] = 0.125*exp(algebraic[1]/80.0); + algebraic[10] = 0.01*(external[1]+10.0)/(exp((external[1]+10.0)/10.0)-1.0); + algebraic[11] = 0.125*exp(external[1]/80.0); rates[1] = algebraic[10]*(1.0-states[1])-algebraic[11]*states[1]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[2] = constants[2]*(algebraic[1]-computedConstants[0]); - algebraic[5] = externalVariable(voi, states, rates, variables, 5); - algebraic[4] = constants[3]*pow(algebraic[5], 3.0)*states[0]*(algebraic[1]-computedConstants[1]); - algebraic[6] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0); - algebraic[7] = 4.0*exp(algebraic[1]/18.0); - algebraic[3] = constants[4]*pow(states[1], 4.0)*(algebraic[1]-computedConstants[2]); + external[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[2] = constants[2]*(external[1]-computedConstants[0]); + external[5] = externalVariable(voi, states, rates, variables, 5); + algebraic[4] = constants[3]*pow(external[5], 3.0)*states[0]*(external[1]-computedConstants[1]); + algebraic[6] = 0.1*(external[1]+25.0)/(exp((external[1]+25.0)/10.0)-1.0); + algebraic[7] = 4.0*exp(external[1]/18.0); + algebraic[3] = constants[4]*pow(states[1], 4.0)*(external[1]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index d9285aa42..a4fb36996 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -93,8 +93,8 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[5] = external_variable(voi, states, rates, variables, 5) + external[1] = external_variable(voi, states, rates, variables, 1) + external[5] = external_variable(voi, states, rates, variables, 5) def compute_computed_constants(constants, computed_constants): @@ -104,21 +104,21 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[8] = 0.07*exp(algebraic[1]/20.0) - algebraic[9] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0) + external[1] = external_variable(voi, states, rates, variables, 1) + algebraic[8] = 0.07*exp(external[1]/20.0) + algebraic[9] = 1.0/(exp((external[1]+30.0)/10.0)+1.0) rates[0] = algebraic[8]*(1.0-states[0])-algebraic[9]*states[0] - algebraic[10] = 0.01*(algebraic[1]+10.0)/(exp((algebraic[1]+10.0)/10.0)-1.0) - algebraic[11] = 0.125*exp(algebraic[1]/80.0) + algebraic[10] = 0.01*(external[1]+10.0)/(exp((external[1]+10.0)/10.0)-1.0) + algebraic[11] = 0.125*exp(external[1]/80.0) rates[1] = algebraic[10]*(1.0-states[1])-algebraic[11]*states[1] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[2] = constants[2]*(algebraic[1]-computed_constants[0]) - algebraic[5] = external_variable(voi, states, rates, variables, 5) - algebraic[4] = constants[3]*pow(algebraic[5], 3.0)*states[0]*(algebraic[1]-computed_constants[1]) - algebraic[6] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0) - algebraic[7] = 4.0*exp(algebraic[1]/18.0) - algebraic[3] = constants[4]*pow(states[1], 4.0)*(algebraic[1]-computed_constants[2]) + external[1] = external_variable(voi, states, rates, variables, 1) + algebraic[2] = constants[2]*(external[1]-computed_constants[0]) + external[5] = external_variable(voi, states, rates, variables, 5) + algebraic[4] = constants[3]*pow(external[5], 3.0)*states[0]*(external[1]-computed_constants[1]) + algebraic[6] = 0.1*(external[1]+25.0)/(exp((external[1]+25.0)/10.0)-1.0) + algebraic[7] = 4.0*exp(external[1]/18.0) + algebraic[3] = constants[4]*pow(states[1], 4.0)*(external[1]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index bb4ff207f..c2572f6cf 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -123,9 +123,9 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[9] = externalVariable(voi, states, rates, variables, 9); - algebraic[4] = externalVariable(voi, states, rates, variables, 4); + external[1] = externalVariable(voi, states, rates, variables, 1); + external[9] = externalVariable(voi, states, rates, variables, 9); + external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) @@ -137,24 +137,24 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[5] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0); - algebraic[6] = 4.0*exp(algebraic[1]/18.0); + external[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[5] = 0.1*(external[1]+25.0)/(exp((external[1]+25.0)/10.0)-1.0); + algebraic[6] = 4.0*exp(external[1]/18.0); rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1]; - algebraic[7] = 0.07*exp(algebraic[1]/20.0); - algebraic[8] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0); + algebraic[7] = 0.07*exp(external[1]/20.0); + algebraic[8] = 1.0/(exp((external[1]+30.0)/10.0)+1.0); rates[0] = algebraic[7]*(1.0-states[0])-algebraic[8]*states[0]; - algebraic[9] = externalVariable(voi, states, rates, variables, 9); - algebraic[10] = 0.125*exp(algebraic[1]/80.0); - rates[2] = algebraic[9]*(1.0-states[2])-algebraic[10]*states[2]; + external[9] = externalVariable(voi, states, rates, variables, 9); + algebraic[10] = 0.125*exp(external[1]/80.0); + rates[2] = external[9]*(1.0-states[2])-algebraic[10]*states[2]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[2] = constants[2]*(algebraic[1]-computedConstants[0]); - algebraic[9] = externalVariable(voi, states, rates, variables, 9); - algebraic[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[3] = constants[4]*pow(states[2], 4.0)*(algebraic[1]-computedConstants[2]); + external[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[2] = constants[2]*(external[1]-computedConstants[0]); + external[9] = externalVariable(voi, states, rates, variables, 9); + external[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[3] = constants[4]*pow(states[2], 4.0)*(external[1]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index e3b132256..5fefa1e03 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -94,9 +94,9 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[9] = external_variable(voi, states, rates, variables, 9) - algebraic[4] = external_variable(voi, states, rates, variables, 4) + external[1] = external_variable(voi, states, rates, variables, 1) + external[9] = external_variable(voi, states, rates, variables, 9) + external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): @@ -106,22 +106,22 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[5] = 0.1*(algebraic[1]+25.0)/(exp((algebraic[1]+25.0)/10.0)-1.0) - algebraic[6] = 4.0*exp(algebraic[1]/18.0) + external[1] = external_variable(voi, states, rates, variables, 1) + algebraic[5] = 0.1*(external[1]+25.0)/(exp((external[1]+25.0)/10.0)-1.0) + algebraic[6] = 4.0*exp(external[1]/18.0) rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1] - algebraic[7] = 0.07*exp(algebraic[1]/20.0) - algebraic[8] = 1.0/(exp((algebraic[1]+30.0)/10.0)+1.0) + algebraic[7] = 0.07*exp(external[1]/20.0) + algebraic[8] = 1.0/(exp((external[1]+30.0)/10.0)+1.0) rates[0] = algebraic[7]*(1.0-states[0])-algebraic[8]*states[0] - algebraic[9] = external_variable(voi, states, rates, variables, 9) - algebraic[10] = 0.125*exp(algebraic[1]/80.0) - rates[2] = algebraic[9]*(1.0-states[2])-algebraic[10]*states[2] + external[9] = external_variable(voi, states, rates, variables, 9) + algebraic[10] = 0.125*exp(external[1]/80.0) + rates[2] = external[9]*(1.0-states[2])-algebraic[10]*states[2] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[1] = external_variable(voi, states, rates, variables, 1) - algebraic[2] = constants[2]*(algebraic[1]-computed_constants[0]) - algebraic[9] = external_variable(voi, states, rates, variables, 9) - algebraic[4] = external_variable(voi, states, rates, variables, 4) - algebraic[3] = constants[4]*pow(states[2], 4.0)*(algebraic[1]-computed_constants[2]) + external[1] = external_variable(voi, states, rates, variables, 1) + algebraic[2] = constants[2]*(external[1]-computed_constants[0]) + external[9] = external_variable(voi, states, rates, variables, 9) + external[4] = external_variable(voi, states, rates, variables, 4) + algebraic[3] = constants[4]*pow(states[2], 4.0)*(external[1]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index fff1a06f0..f5d0d0929 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -123,7 +123,7 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - algebraic[4] = externalVariable(voi, states, rates, variables, 4); + external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) @@ -138,8 +138,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraic[1] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); - algebraic[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[3] = constants[3]*pow(algebraic[4], 3.0)*states[1]*(states[0]-computedConstants[1]); + external[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[3] = constants[3]*pow(external[4], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; algebraic[7] = 0.07*exp(states[0]/20.0); algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); @@ -152,8 +152,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - algebraic[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[3] = constants[3]*pow(algebraic[4], 3.0)*states[1]*(states[0]-computedConstants[1]); + external[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[3] = constants[3]*pow(external[4], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[6] = 4.0*exp(states[0]/18.0); algebraic[7] = 0.07*exp(states[0]/20.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index c9fd02275..27d1d496a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -94,7 +94,7 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - algebraic[4] = external_variable(voi, states, rates, variables, 4) + external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): @@ -107,8 +107,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic[1] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) - algebraic[4] = external_variable(voi, states, rates, variables, 4) - algebraic[3] = constants[3]*pow(algebraic[4], 3.0)*states[1]*(states[0]-computed_constants[1]) + external[4] = external_variable(voi, states, rates, variables, 4) + algebraic[3] = constants[3]*pow(external[4], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] algebraic[7] = 0.07*exp(states[0]/20.0) algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) @@ -120,8 +120,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - algebraic[4] = external_variable(voi, states, rates, variables, 4) - algebraic[3] = constants[3]*pow(algebraic[4], 3.0)*states[1]*(states[0]-computed_constants[1]) + external[4] = external_variable(voi, states, rates, variables, 4) + algebraic[3] = constants[3]*pow(external[4], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[6] = 4.0*exp(states[0]/18.0) algebraic[7] = 0.07*exp(states[0]/20.0) diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 0103461a2..1c1f84b89 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -94,7 +94,7 @@ void initialiseVariables(double *constants, double *algebraic, ExternalVariable constants[5] = 2902500.0; constants[6] = 810000.0; constants[7] = 247140.0; - algebraic[1] = externalVariable(variables, 1); + external[1] = externalVariable(variables, 1); } void computeComputedConstants(double *constants, double *computedConstants) @@ -103,6 +103,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - algebraic[1] = externalVariable(variables, 1); - algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+algebraic[1]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]); + external[1] = externalVariable(variables, 1); + algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+external[1]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]); } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 48f627296..74427a055 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -60,7 +60,7 @@ def initialise_variables(constants, algebraic, external_variable): constants[5] = 2902500.0 constants[6] = 810000.0 constants[7] = 247140.0 - algebraic[1] = external_variable(variables, 1) + external[1] = external_variable(variables, 1) def compute_computed_constants(constants, computed_constants): @@ -68,5 +68,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - algebraic[1] = external_variable(variables, 1) - algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+algebraic[1]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) + external[1] = external_variable(variables, 1) + algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+external[1]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) From 0a05ef9bc427bf2154e85bf6b54ddf221ee93f2a Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 16 Aug 2024 13:49:16 +0200 Subject: [PATCH 28/74] Generator: don't initialise our external variables in initialiseVariables(). There was never a need to initialise them there in the first place. In fact, an external variable is effectively an algebraic variable which is computed by an end user. So, it needs to be computed in computeRates() (if available) and in computeVariables(). Also fixed an issue with initialiseVariables() not always including the VOI. --- src/api/libcellml/generatorprofile.h | 16 +-- src/generator.cpp | 22 +--- src/generatorprofile.cpp | 116 +++++------------- src/generatorprofile_p.h | 14 +-- src/generatorprofilesha1values.h | 4 +- src/generatorprofiletools.cpp | 14 +-- .../javascript/generatorprofile.test.js | 28 ++--- .../bindings/python/test_generator_profile.py | 50 +++----- tests/coverage/coverage.cpp | 1 - tests/generator/generatorprofile.cpp | 56 +++------ tests/resources/coverage/generator/model.c | 2 +- tests/resources/coverage/generator/model.h | 2 +- .../generator/model.implementation.out | 2 +- .../coverage/generator/model.interface.out | 2 +- .../generator/model.modified.profile.c | 2 +- .../generator/model.modified.profile.h | 2 +- .../generator/model.modified.profile.py | 2 +- tests/resources/coverage/generator/model.out | 2 +- tests/resources/coverage/generator/model.py | 2 +- .../model.external.c | 3 +- .../model.external.h | 2 +- .../model.external.py | 4 +- .../algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs/model.h | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs/model.h | 2 +- .../algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.external.c | 3 +- .../model.external.h | 2 +- .../model.external.py | 4 +- .../model.three.externals.c | 5 +- .../model.three.externals.h | 2 +- .../model.three.externals.py | 6 +- .../cell_geometry_model/model.external.c | 4 +- .../cell_geometry_model/model.external.h | 2 +- .../cell_geometry_model/model.external.py | 5 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../cellml_unit_scaling_rate/model.c | 2 +- .../cellml_unit_scaling_rate/model.h | 2 +- .../cellml_unit_scaling_rate/model.py | 2 +- .../cellml_unit_scaling_state/model.c | 2 +- .../cellml_unit_scaling_state/model.h | 2 +- .../cellml_unit_scaling_state/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../cellml_unit_scaling_voi_direct/model.c | 2 +- .../cellml_unit_scaling_voi_direct/model.h | 2 +- .../cellml_unit_scaling_voi_direct/model.py | 2 +- .../cellml_unit_scaling_voi_indirect/model.c | 2 +- .../cellml_unit_scaling_voi_indirect/model.h | 2 +- .../cellml_unit_scaling_voi_indirect/model.py | 2 +- .../generator/dae_cellml_1_1_model/model.c | 2 +- .../generator/dae_cellml_1_1_model/model.h | 2 +- .../generator/dae_cellml_1_1_model/model.py | 2 +- .../generator/dependent_eqns/model.c | 2 +- .../generator/dependent_eqns/model.h | 2 +- .../generator/dependent_eqns/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.algebraic.c | 3 +- .../model.algebraic.h | 2 +- .../model.algebraic.py | 3 +- .../model.c | 2 +- .../model.computed.constant.c | 3 +- .../model.computed.constant.h | 2 +- .../model.computed.constant.py | 3 +- .../model.constant.c | 3 +- .../model.constant.h | 2 +- .../model.constant.py | 3 +- .../model.dae.c | 2 +- .../model.dae.h | 2 +- .../model.dae.py | 2 +- .../model.dependent.algebraic.c | 4 +- .../model.dependent.algebraic.h | 2 +- .../model.dependent.algebraic.py | 4 +- .../model.dependent.computed.constant.c | 4 +- .../model.dependent.computed.constant.h | 2 +- .../model.dependent.computed.constant.py | 4 +- .../model.dependent.constant.c | 4 +- .../model.dependent.constant.h | 2 +- .../model.dependent.constant.py | 4 +- .../model.dependent.state.c | 4 +- .../model.dependent.state.h | 2 +- .../model.dependent.state.py | 4 +- .../model.external.c | 5 +- .../model.external.h | 2 +- .../model.external.py | 5 +- .../model.h | 2 +- .../model.py | 2 +- .../model.state.c | 3 +- .../model.state.h | 2 +- .../model.state.py | 3 +- .../generator/noble_model_1962/model.c | 2 +- .../generator/noble_model_1962/model.h | 2 +- .../generator/noble_model_1962/model.py | 2 +- .../generator/ode_computed_var_on_rhs/model.c | 2 +- .../generator/ode_computed_var_on_rhs/model.h | 2 +- .../ode_computed_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/ode_const_var_on_rhs/model.c | 2 +- .../generator/ode_const_var_on_rhs/model.h | 2 +- .../generator/ode_const_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/ode_constant_on_rhs/model.c | 2 +- .../generator/ode_constant_on_rhs/model.h | 2 +- .../generator/ode_constant_on_rhs/model.py | 2 +- .../ode_constant_on_rhs_one_component/model.c | 2 +- .../ode_constant_on_rhs_one_component/model.h | 2 +- .../model.py | 2 +- .../ode_multiple_dependent_odes/model.c | 2 +- .../ode_multiple_dependent_odes/model.h | 2 +- .../ode_multiple_dependent_odes/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../ode_multiple_odes_with_same_name/model.c | 2 +- .../ode_multiple_odes_with_same_name/model.h | 2 +- .../ode_multiple_odes_with_same_name/model.py | 2 +- .../generator/ode_unknown_var_on_rhs/model.c | 2 +- .../generator/ode_unknown_var_on_rhs/model.h | 2 +- .../generator/ode_unknown_var_on_rhs/model.py | 2 +- .../robertson_model_1966/model.dae.c | 2 +- .../robertson_model_1966/model.dae.h | 2 +- .../robertson_model_1966/model.dae.py | 2 +- .../robertson_model_1966/model.ode.c | 2 +- .../robertson_model_1966/model.ode.h | 2 +- .../robertson_model_1966/model.ode.py | 2 +- .../generator/sine_model_imports/model.c | 2 +- .../generator/sine_model_imports/model.h | 2 +- .../generator/sine_model_imports/model.py | 2 +- .../model.c | 3 +- .../model.h | 2 +- .../model.py | 3 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- 160 files changed, 234 insertions(+), 437 deletions(-) diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index ae367e295..33b889c11 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -3686,13 +3686,10 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the interface to initialise variables * is for a differential model, as opposed to an algebraic model. - * @param withExternalVariables Whether the interface to initialise - * variables is for a model with external variables. * * @return The @c std::string for the interface to initialise variables. */ - std::string interfaceInitialiseVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables) const; + std::string interfaceInitialiseVariablesMethodString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the interface to initialise variables. @@ -3701,13 +3698,10 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the interface to initialise variables * is for a differential model, as opposed to an algebraic model. - * @param withExternalVariables Whether the interface to initialise - * variables is for a model with external variables. * @param interfaceInitialiseVariablesMethodString The @c std::string to use * for the interface to initialise variables. */ void setInterfaceInitialiseVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables, const std::string &interfaceInitialiseVariablesMethodString); /** @@ -3718,14 +3712,11 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the implementation to initialise * variables is for a differential model, as opposed to an algebraic model. - * @param withExternalVariables Whether the implementation to initialise - * variables is for a model with external variables. * * @return The @c std::string for the implementation to initialise * variables. */ - std::string implementationInitialiseVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables) const; + std::string implementationInitialiseVariablesMethodString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the implementation to initialise @@ -3737,13 +3728,10 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the implementation to initialise * variables is for a differential model, as opposed to an algebraic model. - * @param withExternalVariables Whether the implementation to initialise - * variables is for a model with external variables. * @param implementationInitialiseVariablesMethodString The @c std::string * to use for the implementation to initialise variables. */ void setImplementationInitialiseVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables, const std::string &implementationInitialiseVariablesMethodString); /** diff --git a/src/generator.cpp b/src/generator.cpp index ce6cc531f..23a46e90d 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1776,8 +1776,7 @@ std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquatio void Generator::GeneratorImpl::addInterfaceComputeModelMethodsCode() { - auto interfaceInitialiseVariablesMethodString = mProfile->interfaceInitialiseVariablesMethodString(modelHasOdes(), - mModel->hasExternalVariables()); + auto interfaceInitialiseVariablesMethodString = mProfile->interfaceInitialiseVariablesMethodString(modelHasOdes()); std::string code; if (!interfaceInitialiseVariablesMethodString.empty()) { @@ -1811,8 +1810,7 @@ void Generator::GeneratorImpl::addInterfaceComputeModelMethodsCode() void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(std::vector &remainingEquations) { - auto implementationInitialiseVariablesMethodString = mProfile->implementationInitialiseVariablesMethodString(modelHasOdes(), - mModel->hasExternalVariables()); + auto implementationInitialiseVariablesMethodString = mProfile->implementationInitialiseVariablesMethodString(modelHasOdes()); if (!implementationInitialiseVariablesMethodString.empty()) { // Initialise our states. @@ -1876,22 +1874,6 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st } } - // Initialise our external variables. - - if (mModel->hasExternalVariables()) { - std::vector remainingExternalEquations; - - std::copy_if(equations.begin(), equations.end(), - std::back_inserter(remainingExternalEquations), - [](const AnalyserEquationPtr &equation) { return equation->type() == AnalyserEquation::Type::EXTERNAL; }); - - for (const auto &equation : equations) { - if (equation->type() == AnalyserEquation::Type::EXTERNAL) { - methodBody += generateEquationCode(equation, remainingExternalEquations); - } - } - } - mCode += newLineIfNeeded() + replace(implementationInitialiseVariablesMethodString, "[CODE]", generateMethodBodyCode(methodBody)); diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index bc191920b..8de812817 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -409,29 +409,17 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " free(array);\n" "}\n"; - mInterfaceInitialiseVariablesMethodFamWoevString = "void initialiseVariables(double *constants, double *algebraic);\n"; - mImplementationInitialiseVariablesMethodFamWoevString = "void initialiseVariables(double *constants, double *algebraic)\n" - "{\n" - "[CODE]" - "}\n"; - - mInterfaceInitialiseVariablesMethodFamWevString = "void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable);\n"; - mImplementationInitialiseVariablesMethodFamWevString = "void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable)\n" - "{\n" - "[CODE]" - "}\n"; - - mInterfaceInitialiseVariablesMethodFdmWoevString = "void initialiseVariables(double *states, double *rates, double *constants, double *algebraic);\n"; - mImplementationInitialiseVariablesMethodFdmWoevString = "void initialiseVariables(double *states, double *rates, double *constants, double *algebraic)\n" - "{\n" - "[CODE]" - "}\n"; - - mInterfaceInitialiseVariablesMethodFdmWevString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable);\n"; - mImplementationInitialiseVariablesMethodFdmWevString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable)\n" - "{\n" - "[CODE]" - "}\n"; + mInterfaceInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *algebraic);\n"; + mImplementationInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *algebraic)\n" + "{\n" + "[CODE]" + "}\n"; + + mInterfaceInitialiseVariablesMethodFdmString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic);\n"; + mImplementationInitialiseVariablesMethodFdmString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic)\n" + "{\n" + "[CODE]" + "}\n"; mInterfaceComputeComputedConstantsMethodString = "void computeComputedConstants(double *constants, double *computedConstants);\n"; mImplementationComputeComputedConstantsMethodString = "void computeComputedConstants(double *constants, double *computedConstants)\n" @@ -812,25 +800,15 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceDeleteArrayMethodString = ""; mImplementationDeleteArrayMethodString = ""; - mInterfaceInitialiseVariablesMethodFamWoevString = ""; - mImplementationInitialiseVariablesMethodFamWoevString = "\n" - "def initialise_variables(constants, algebraic):\n" - "[CODE]"; - - mInterfaceInitialiseVariablesMethodFamWevString = ""; - mImplementationInitialiseVariablesMethodFamWevString = "\n" - "def initialise_variables(constants, algebraic, external_variable):\n" - "[CODE]"; - - mInterfaceInitialiseVariablesMethodFdmWoevString = ""; - mImplementationInitialiseVariablesMethodFdmWoevString = "\n" - "def initialise_variables(states, rates, constants, algebraic):\n" - "[CODE]"; + mInterfaceInitialiseVariablesMethodFamString = ""; + mImplementationInitialiseVariablesMethodFamString = "\n" + "def initialise_variables(constants, algebraic):\n" + "[CODE]"; - mInterfaceInitialiseVariablesMethodFdmWevString = ""; - mImplementationInitialiseVariablesMethodFdmWevString = "\n" - "def initialise_variables(voi, states, rates, constants, algebraic, external_variable):\n" - "[CODE]"; + mInterfaceInitialiseVariablesMethodFdmString = ""; + mImplementationInitialiseVariablesMethodFdmString = "\n" + "def initialise_variables(voi, states, rates, constants, algebraic):\n" + "[CODE]"; mInterfaceComputeComputedConstantsMethodString = ""; mImplementationComputeComputedConstantsMethodString = "\n" @@ -2583,77 +2561,41 @@ void GeneratorProfile::setImplementationDeleteArrayMethodString(const std::strin mPimpl->mImplementationDeleteArrayMethodString = implementationDeleteArrayMethodString; } -std::string GeneratorProfile::interfaceInitialiseVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables) const +std::string GeneratorProfile::interfaceInitialiseVariablesMethodString(bool forDifferentialModel) const { if (forDifferentialModel) { - if (withExternalVariables) { - return mPimpl->mInterfaceInitialiseVariablesMethodFdmWevString; - } - - return mPimpl->mInterfaceInitialiseVariablesMethodFdmWoevString; + return mPimpl->mInterfaceInitialiseVariablesMethodFdmString; } - if (withExternalVariables) { - return mPimpl->mInterfaceInitialiseVariablesMethodFamWevString; - } - - return mPimpl->mInterfaceInitialiseVariablesMethodFamWoevString; + return mPimpl->mInterfaceInitialiseVariablesMethodFamString; } void GeneratorProfile::setInterfaceInitialiseVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables, const std::string &interfaceInitialiseVariablesMethodString) { if (forDifferentialModel) { - if (withExternalVariables) { - mPimpl->mInterfaceInitialiseVariablesMethodFdmWevString = interfaceInitialiseVariablesMethodString; - } else { - mPimpl->mInterfaceInitialiseVariablesMethodFdmWoevString = interfaceInitialiseVariablesMethodString; - } + mPimpl->mInterfaceInitialiseVariablesMethodFdmString = interfaceInitialiseVariablesMethodString; } else { - if (withExternalVariables) { - mPimpl->mInterfaceInitialiseVariablesMethodFamWevString = interfaceInitialiseVariablesMethodString; - } else { - mPimpl->mInterfaceInitialiseVariablesMethodFamWoevString = interfaceInitialiseVariablesMethodString; - } + mPimpl->mInterfaceInitialiseVariablesMethodFamString = interfaceInitialiseVariablesMethodString; } } -std::string GeneratorProfile::implementationInitialiseVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables) const +std::string GeneratorProfile::implementationInitialiseVariablesMethodString(bool forDifferentialModel) const { if (forDifferentialModel) { - if (withExternalVariables) { - return mPimpl->mImplementationInitialiseVariablesMethodFdmWevString; - } - - return mPimpl->mImplementationInitialiseVariablesMethodFdmWoevString; + return mPimpl->mImplementationInitialiseVariablesMethodFdmString; } - if (withExternalVariables) { - return mPimpl->mImplementationInitialiseVariablesMethodFamWevString; - } - - return mPimpl->mImplementationInitialiseVariablesMethodFamWoevString; + return mPimpl->mImplementationInitialiseVariablesMethodFamString; } void GeneratorProfile::setImplementationInitialiseVariablesMethodString(bool forDifferentialModel, - bool withExternalVariables, const std::string &implementationInitialiseVariablesMethodString) { if (forDifferentialModel) { - if (withExternalVariables) { - mPimpl->mImplementationInitialiseVariablesMethodFdmWevString = implementationInitialiseVariablesMethodString; - } else { - mPimpl->mImplementationInitialiseVariablesMethodFdmWoevString = implementationInitialiseVariablesMethodString; - } + mPimpl->mImplementationInitialiseVariablesMethodFdmString = implementationInitialiseVariablesMethodString; } else { - if (withExternalVariables) { - mPimpl->mImplementationInitialiseVariablesMethodFamWevString = implementationInitialiseVariablesMethodString; - } else { - mPimpl->mImplementationInitialiseVariablesMethodFamWoevString = implementationInitialiseVariablesMethodString; - } + mPimpl->mImplementationInitialiseVariablesMethodFamString = implementationInitialiseVariablesMethodString; } } diff --git a/src/generatorprofile_p.h b/src/generatorprofile_p.h index 167f8ab23..5ab7bb5a7 100644 --- a/src/generatorprofile_p.h +++ b/src/generatorprofile_p.h @@ -257,17 +257,11 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mInterfaceDeleteArrayMethodString; std::string mImplementationDeleteArrayMethodString; - std::string mInterfaceInitialiseVariablesMethodFamWoevString; - std::string mImplementationInitialiseVariablesMethodFamWoevString; + std::string mInterfaceInitialiseVariablesMethodFamString; + std::string mImplementationInitialiseVariablesMethodFamString; - std::string mInterfaceInitialiseVariablesMethodFamWevString; - std::string mImplementationInitialiseVariablesMethodFamWevString; - - std::string mInterfaceInitialiseVariablesMethodFdmWoevString; - std::string mImplementationInitialiseVariablesMethodFdmWoevString; - - std::string mInterfaceInitialiseVariablesMethodFdmWevString; - std::string mImplementationInitialiseVariablesMethodFdmWevString; + std::string mInterfaceInitialiseVariablesMethodFdmString; + std::string mImplementationInitialiseVariablesMethodFdmString; std::string mInterfaceComputeComputedConstantsMethodString; std::string mImplementationComputeComputedConstantsMethodString; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index c96cffaf2..dacc0b264 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "54ee603459d7878ee469890e77de4f3dbb5452ad"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "bf42c06955e401096d76d059a28ed1a5cb1ccc01"; +static const char C_GENERATOR_PROFILE_SHA1[] = "323f0e5824d5c794c28f34dda5e7410efc836e62"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "3f6672212636b5179b23b9664cead525f54f665f"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index 5fa609392..d68bb59bc 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -523,17 +523,11 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->interfaceDeleteArrayMethodString() + generatorProfile->implementationDeleteArrayMethodString(); - profileContents += generatorProfile->interfaceInitialiseVariablesMethodString(false, false) - + generatorProfile->implementationInitialiseVariablesMethodString(false, false); + profileContents += generatorProfile->interfaceInitialiseVariablesMethodString(false) + + generatorProfile->implementationInitialiseVariablesMethodString(false); - profileContents += generatorProfile->interfaceInitialiseVariablesMethodString(false, true) - + generatorProfile->implementationInitialiseVariablesMethodString(false, true); - - profileContents += generatorProfile->interfaceInitialiseVariablesMethodString(true, false) - + generatorProfile->implementationInitialiseVariablesMethodString(true, false); - - profileContents += generatorProfile->interfaceInitialiseVariablesMethodString(true, true) - + generatorProfile->implementationInitialiseVariablesMethodString(true, true); + profileContents += generatorProfile->interfaceInitialiseVariablesMethodString(true) + + generatorProfile->implementationInitialiseVariablesMethodString(true); profileContents += generatorProfile->interfaceComputeComputedConstantsMethodString() + generatorProfile->implementationComputeComputedConstantsMethodString(); diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index e1f63eee4..7d1a1cc84 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -1014,32 +1014,20 @@ describe("GeneratorProfile tests", () => { test("Checking GeneratorProfile.interfaceInitialiseVariablesMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceInitialiseVariablesMethodString(false, false, "something") - expect(x.interfaceInitialiseVariablesMethodString(false, false)).toBe("something") + x.setInterfaceInitialiseVariablesMethodString(false, "something") + expect(x.interfaceInitialiseVariablesMethodString(false)).toBe("something") - x.setInterfaceInitialiseVariablesMethodString(false, true, "something") - expect(x.interfaceInitialiseVariablesMethodString(false, true)).toBe("something") - - x.setInterfaceInitialiseVariablesMethodString(true, false, "something") - expect(x.interfaceInitialiseVariablesMethodString(true, false)).toBe("something") - - x.setInterfaceInitialiseVariablesMethodString(true, true, "something") - expect(x.interfaceInitialiseVariablesMethodString(true, true)).toBe("something") + x.setInterfaceInitialiseVariablesMethodString(true, "something") + expect(x.interfaceInitialiseVariablesMethodString(true)).toBe("something") }); test("Checking GeneratorProfile.implementationInitialiseVariablesMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationInitialiseVariablesMethodString(false, false, "something") - expect(x.implementationInitialiseVariablesMethodString(false, false)).toBe("something") - - x.setImplementationInitialiseVariablesMethodString(false, true, "something") - expect(x.implementationInitialiseVariablesMethodString(false, true)).toBe("something") - - x.setImplementationInitialiseVariablesMethodString(true, false, "something") - expect(x.implementationInitialiseVariablesMethodString(true, false)).toBe("something") + x.setImplementationInitialiseVariablesMethodString(false, "something") + expect(x.implementationInitialiseVariablesMethodString(false)).toBe("something") - x.setImplementationInitialiseVariablesMethodString(true, true, "something") - expect(x.implementationInitialiseVariablesMethodString(true, true)).toBe("something") + x.setImplementationInitialiseVariablesMethodString(true, "something") + expect(x.implementationInitialiseVariablesMethodString(true)).toBe("something") }); test("Checking GeneratorProfile.interfaceComputeComputedConstantsMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 51d67a723..c030ba9c8 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -839,24 +839,14 @@ def test_implementation_initialise_constants_method_string(self): g = GeneratorProfile() self.assertEqual('void initialiseVariables(double *constants, double *algebraic)\n{\n[CODE]}\n', - g.implementationInitialiseVariablesMethodString(False, False)) - g.setImplementationInitialiseVariablesMethodString(False, False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(False, False)) + g.implementationInitialiseVariablesMethodString(False)) + g.setImplementationInitialiseVariablesMethodString(False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(False)) - self.assertEqual('void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable)\n{\n[CODE]}\n', - g.implementationInitialiseVariablesMethodString(False, True)) - g.setImplementationInitialiseVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(False, True)) - - self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *algebraic)\n{\n[CODE]}\n', - g.implementationInitialiseVariablesMethodString(True, False)) - g.setImplementationInitialiseVariablesMethodString(True, False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(True, False)) - - self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable)\n{\n[CODE]}\n', - g.implementationInitialiseVariablesMethodString(True, True)) - g.setImplementationInitialiseVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(True, True)) + self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic)\n{\n[CODE]}\n', + g.implementationInitialiseVariablesMethodString(True)) + g.setImplementationInitialiseVariablesMethodString(True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(True)) def test_implementation_libcellml_version_string(self): from libcellml import GeneratorProfile @@ -1128,24 +1118,14 @@ def test_interface_initialise_constants_method_string(self): g = GeneratorProfile() self.assertEqual('void initialiseVariables(double *constants, double *algebraic);\n', - g.interfaceInitialiseVariablesMethodString(False, False)) - g.setInterfaceInitialiseVariablesMethodString(False, False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(False, False)) - - self.assertEqual('void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable);\n', - g.interfaceInitialiseVariablesMethodString(False, True)) - g.setInterfaceInitialiseVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(False, True)) - - self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *algebraic);\n', - g.interfaceInitialiseVariablesMethodString(True, False)) - g.setInterfaceInitialiseVariablesMethodString(True, False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(True, False)) - - self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable);\n', - g.interfaceInitialiseVariablesMethodString(True, True)) - g.setInterfaceInitialiseVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(True, True)) + g.interfaceInitialiseVariablesMethodString(False)) + g.setInterfaceInitialiseVariablesMethodString(False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(False)) + + self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic);\n', + g.interfaceInitialiseVariablesMethodString(True)) + g.setInterfaceInitialiseVariablesMethodString(True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(True)) def test_interface_libcellml_version_string(self): from libcellml import GeneratorProfile diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 097dcdacc..cd9654184 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -875,7 +875,6 @@ TEST(Coverage, generator) profile->setImplementationComputeComputedConstantsMethodString(""); profile->setImplementationComputeRatesMethodString(true, ""); profile->setImplementationHeaderString("[INTERFACE_FILE_NAME]"); - profile->setImplementationInitialiseVariablesMethodString(true, true, ""); profile->setInterfaceFileNameString(""); profile->setInterfaceHeaderString(""); profile->setMaxFunctionString(""); diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index aa91c910a..155af5a07 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -487,36 +487,20 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) generatorProfile->implementationDeleteArrayMethodString()); EXPECT_EQ("void initialiseVariables(double *constants, double *algebraic);\n", - generatorProfile->interfaceInitialiseVariablesMethodString(false, false)); + generatorProfile->interfaceInitialiseVariablesMethodString(false)); EXPECT_EQ("void initialiseVariables(double *constants, double *algebraic)\n" "{\n" "[CODE]" "}\n", - generatorProfile->implementationInitialiseVariablesMethodString(false, false)); + generatorProfile->implementationInitialiseVariablesMethodString(false)); - EXPECT_EQ("void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable);\n", - generatorProfile->interfaceInitialiseVariablesMethodString(false, true)); - EXPECT_EQ("void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable)\n" + EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic);\n", + generatorProfile->interfaceInitialiseVariablesMethodString(true)); + EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic)\n" "{\n" "[CODE]" "}\n", - generatorProfile->implementationInitialiseVariablesMethodString(false, true)); - - EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *algebraic);\n", - generatorProfile->interfaceInitialiseVariablesMethodString(true, false)); - EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *algebraic)\n" - "{\n" - "[CODE]" - "}\n", - generatorProfile->implementationInitialiseVariablesMethodString(true, false)); - - EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable);\n", - generatorProfile->interfaceInitialiseVariablesMethodString(true, true)); - EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable)\n" - "{\n" - "[CODE]" - "}\n", - generatorProfile->implementationInitialiseVariablesMethodString(true, true)); + generatorProfile->implementationInitialiseVariablesMethodString(true)); EXPECT_EQ("void computeComputedConstants(double *constants, double *computedConstants);\n", generatorProfile->interfaceComputeComputedConstantsMethodString()); @@ -979,17 +963,11 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setInterfaceDeleteArrayMethodString(value); generatorProfile->setImplementationDeleteArrayMethodString(value); - generatorProfile->setInterfaceInitialiseVariablesMethodString(false, false, value); - generatorProfile->setImplementationInitialiseVariablesMethodString(false, false, value); - - generatorProfile->setInterfaceInitialiseVariablesMethodString(false, true, value); - generatorProfile->setImplementationInitialiseVariablesMethodString(false, true, value); + generatorProfile->setInterfaceInitialiseVariablesMethodString(false, value); + generatorProfile->setImplementationInitialiseVariablesMethodString(false, value); - generatorProfile->setInterfaceInitialiseVariablesMethodString(true, false, value); - generatorProfile->setImplementationInitialiseVariablesMethodString(true, false, value); - - generatorProfile->setInterfaceInitialiseVariablesMethodString(true, true, value); - generatorProfile->setImplementationInitialiseVariablesMethodString(true, true, value); + generatorProfile->setInterfaceInitialiseVariablesMethodString(true, value); + generatorProfile->setImplementationInitialiseVariablesMethodString(true, value); generatorProfile->setInterfaceComputeComputedConstantsMethodString(value); generatorProfile->setImplementationComputeComputedConstantsMethodString(value); @@ -1126,17 +1104,11 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->interfaceDeleteArrayMethodString()); EXPECT_EQ(value, generatorProfile->implementationDeleteArrayMethodString()); - EXPECT_EQ(value, generatorProfile->interfaceInitialiseVariablesMethodString(false, false)); - EXPECT_EQ(value, generatorProfile->implementationInitialiseVariablesMethodString(false, false)); - - EXPECT_EQ(value, generatorProfile->interfaceInitialiseVariablesMethodString(false, true)); - EXPECT_EQ(value, generatorProfile->implementationInitialiseVariablesMethodString(false, true)); - - EXPECT_EQ(value, generatorProfile->interfaceInitialiseVariablesMethodString(true, false)); - EXPECT_EQ(value, generatorProfile->implementationInitialiseVariablesMethodString(true, false)); + EXPECT_EQ(value, generatorProfile->interfaceInitialiseVariablesMethodString(false)); + EXPECT_EQ(value, generatorProfile->implementationInitialiseVariablesMethodString(false)); - EXPECT_EQ(value, generatorProfile->interfaceInitialiseVariablesMethodString(true, true)); - EXPECT_EQ(value, generatorProfile->implementationInitialiseVariablesMethodString(true, true)); + EXPECT_EQ(value, generatorProfile->interfaceInitialiseVariablesMethodString(true)); + EXPECT_EQ(value, generatorProfile->implementationInitialiseVariablesMethodString(true)); EXPECT_EQ(value, generatorProfile->interfaceComputeComputedConstantsMethodString()); EXPECT_EQ(value, generatorProfile->implementationComputeComputedConstantsMethodString()); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 8ba9f8fd4..72b66e639 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -405,7 +405,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index f41310108..5d9a4cbdc 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 4e3c75233..9879365ae 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -168,7 +168,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index bd773bffa..5fa121175 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -11,7 +11,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 32e5b78d5..4d98fe81b 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -405,7 +405,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 482f4f6c3..99e4b49f1 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 5c5e36cbd..eb7f0514f 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -383,7 +383,7 @@ def find_root_0(voi, states, rates, variables): algebraic[1] = u[1] -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 constants[0] = 1.0 constants[1] = 2.0 diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index 63ed9abc2..d57486a8d 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -116,7 +116,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index b36dad8de..8f5da46a7 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -383,7 +383,7 @@ def find_root_0(voi, states, rates, variables): algebraic[1] = u[1] -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 constants[0] = 1.0 constants[1] = 2.0 diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 9dc593142..cae10b971 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -76,9 +76,8 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double *constants, double *algebraic) { - external[1] = externalVariable(variables, 1); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index 3aea6ecea..96a917b0a 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 56bde48d8..293eda06d 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -43,8 +43,8 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, algebraic, external_variable): - external[1] = external_variable(variables, 1) +def initialise_variables(constants, algebraic): + pass def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 8050184e0..014cbdc35 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index a78dbb906..fe567bfd6 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 0da204aec..c82c2e861 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 37466c281..c87a0e1ce 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index e05d29846..d2fac6dd0 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index ffb5d2a00..427ddf5b9 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 9c9f2695d..92edb5255 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index ba0e44b67..57b67a4db 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 1c3a92bcd..a2c96535a 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index f8e0f2101..7e852f4e1 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index a33a6c600..2cb538a2f 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index e1d0ff117..a16626a8f 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index fcf0650ff..2d502bbe6 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -78,9 +78,8 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double *constants, double *algebraic) { - external[0] = externalVariable(variables, 0); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index 3aea6ecea..96a917b0a 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index c55a3656b..67217abb1 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -45,8 +45,8 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, algebraic, external_variable): - external[0] = external_variable(variables, 0) +def initialise_variables(constants, algebraic): + pass def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index 1a1de087c..620fc5523 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -77,11 +77,8 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double *constants, double *algebraic) { - external[0] = externalVariable(variables, 0); - external[1] = externalVariable(variables, 1); - external[2] = externalVariable(variables, 2); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index ec5b81c77..63c13e639 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index f83da06d0..1b2b68c5f 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -44,10 +44,8 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, algebraic, external_variable): - external[0] = external_variable(variables, 0) - external[1] = external_variable(variables, 1) - external[2] = external_variable(variables, 2) +def initialise_variables(constants, algebraic): + pass def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 9443a6222..d20c18769 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -78,10 +78,8 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double *constants, double *algebraic) { - external[1] = externalVariable(variables, 1); - external[2] = externalVariable(variables, 2); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index c7ef02ef1..0fc34b150 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 5549575c3..734dbc14e 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -45,9 +45,8 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, algebraic, external_variable): - external[1] = external_variable(variables, 1) - external[2] = external_variable(variables, 2) +def initialise_variables(constants, algebraic): + pass def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 4e23c77de..17813b55b 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index e55d0f0e3..43685c5ba 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index cc23dc6d1..75604f927 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -47,7 +47,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 states[1] = 0.0 diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index 311dad8ea..a146b4d20 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = constants[0]; constants[0] = 123.0; diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index c7fc1bb53..ab266738e 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 7da7403e9..032002fb9 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = constants[0] constants[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 053937550..d714d284d 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index c7fc1bb53..ab266738e 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 1e36dfbf7..8b002e808 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 4ebce78ef..b9aa6f1bc 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index c7fc1bb53..ab266738e 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index b76901fc5..a419ddf98 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index 4ae30b4c2..f98746f5c 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 123.0; states[1] = 0.001*789.0; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index dd0b1fd5c..e56356d45 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index 212fca2d8..fd82e9c5f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 123.0 states[1] = 0.001*789.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index d4036cd8f..363343cd2 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = constants[0]; states[1] = 0.001*constants[1]; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 7267fab5d..67cbb918d 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index f60e5e970..7e03b6de1 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -47,7 +47,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = constants[0] states[1] = 0.001*constants[1] constants[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index 3f3b30f11..d545a0557 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 3.0; states[1] = 5.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index 351e9dc86..e29840b4e 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index bed26c278..2d7f9ee98 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 3.0 states[1] = 5.0 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index cc5275106..1a7319f7d 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 3.0; states[1] = 7.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 487f6a748..c5193145b 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index 5d5db3945..9bc446530 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 3.0 states[1] = 7.0 states[2] = 11.0 diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index d32cd7b90..b4a2873d6 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -146,7 +146,7 @@ void findRoot1(double voi, double *states, double *rates, double *variables) algebraic[4] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index f4325a88b..d677f483c 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index a65bd2932..b5f846ce9 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -100,7 +100,7 @@ def find_root_1(voi, states, rates, variables): algebraic[4] = u[0] -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 states[1] = 0.0 constants[0] = 1.0 diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index da657936c..48ab41d0c 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 2a63e4ec5..428425c58 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index b415fdb96..e808d821c 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 20d93a9cc..a8a5216a2 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -326,7 +326,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 6.226104e-5; states[1] = 5.0; diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 91a04ff7d..911283f31 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 379a01e73..aa0f5640b 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -313,7 +313,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 6.226104e-5 states[1] = 5.0 states[2] = 0.409551 diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 95cebcd3a..359ef0869 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -276,7 +276,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = -39.013558536; states[1] = 0.092361701692; diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 96bd8c9d2..817cb1544 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 0b6a2012a..1817e152e 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -251,7 +251,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = -39.013558536 states[1] = 0.092361701692 states[2] = 0.015905380261 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index e0dcf3cb1..d81cafe4e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; @@ -124,7 +124,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - external[0] = externalVariable(voi, states, rates, variables, 0); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index 543f64ae8..857b7d32f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 264db7750..ddf22acb1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -95,7 +95,6 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - external[0] = external_variable(voi, states, rates, variables, 0) def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 055c69796..399b824ff 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -98,7 +98,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index f5534292a..42fbe0421 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; @@ -124,7 +124,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index 543f64ae8..857b7d32f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 825c30cc9..ebabb1f34 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -95,7 +95,6 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 7d3412568..48d149994 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; @@ -123,7 +123,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[1] = 0.3; constants[2] = 120.0; constants[3] = 36.0; - external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index 543f64ae8..857b7d32f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 32d9a44ba..82efd710e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -94,7 +94,6 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[1] = 0.3 constants[2] = 120.0 constants[3] = 36.0 - external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index f929e387f..25ffe82fe 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -516,7 +516,7 @@ void findRoot16(double voi, double *states, double *rates, double *variables) rates[3] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index 6dead540c..07842acfd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 4dc671937..6a67ef421 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -437,7 +437,7 @@ def find_root_16(voi, states, rates, variables): rates[3] = u[0] -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index b91929dbd..6631f821e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; @@ -124,8 +124,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - external[9] = externalVariable(voi, states, rates, variables, 9); - external[0] = externalVariable(voi, states, rates, variables, 0); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index 543f64ae8..857b7d32f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 243b736f0..69623430c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -95,8 +95,6 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - external[9] = external_variable(voi, states, rates, variables, 9) - external[0] = external_variable(voi, states, rates, variables, 0) def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 35de38cb5..a51d46112 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; @@ -123,8 +123,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[1] = 0.3; constants[2] = 120.0; constants[3] = 36.0; - external[11] = externalVariable(voi, states, rates, variables, 11); - external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index 543f64ae8..857b7d32f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 0da4974b2..4dd723021 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -94,8 +94,6 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[1] = 0.3 constants[2] = 120.0 constants[3] = 36.0 - external[11] = external_variable(voi, states, rates, variables, 11) - external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index cc74be6ce..004ed3c37 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; @@ -122,8 +122,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[0] = 0.0; constants[1] = 0.3; constants[2] = 36.0; - external[5] = externalVariable(voi, states, rates, variables, 5); - external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index 543f64ae8..857b7d32f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 9ffe1b12a..05478b926 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -93,8 +93,6 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[0] = 0.0 constants[1] = 0.3 constants[2] = 36.0 - external[5] = external_variable(voi, states, rates, variables, 5) - external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 3f7fde086..c5a4fdcb3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.6; states[1] = 0.325; @@ -122,8 +122,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - external[1] = externalVariable(voi, states, rates, variables, 1); - external[5] = externalVariable(voi, states, rates, variables, 5); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index 543f64ae8..857b7d32f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index a4fb36996..f02d4bbc1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.6 states[1] = 0.325 constants[0] = 1.0 @@ -93,8 +93,6 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - external[1] = external_variable(voi, states, rates, variables, 1) - external[5] = external_variable(voi, states, rates, variables, 5) def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index c2572f6cf..968d381c8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.6; states[1] = 0.05; @@ -123,9 +123,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - external[1] = externalVariable(voi, states, rates, variables, 1); - external[9] = externalVariable(voi, states, rates, variables, 9); - external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index 543f64ae8..857b7d32f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 5fefa1e03..d533782ea 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.6 states[1] = 0.05 states[2] = 0.325 @@ -94,9 +94,6 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - external[1] = external_variable(voi, states, rates, variables, 1) - external[9] = external_variable(voi, states, rates, variables, 9) - external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index 6dead540c..07842acfd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 7aaf3feb1..2a50b6d32 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -77,7 +77,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index f5d0d0929..64e677b50 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; @@ -123,7 +123,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - external[4] = externalVariable(voi, states, rates, variables, 4); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index 543f64ae8..857b7d32f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 27d1d496a..bd4d565ed 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic, external_variable): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.325 @@ -94,7 +94,6 @@ def initialise_variables(voi, states, rates, constants, algebraic, external_vari constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - external[4] = external_variable(voi, states, rates, variables, 4) def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 7b978a5a7..e827ed239 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -97,7 +97,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = -87.0; states[1] = 0.01; diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index 3814979f5..e3b78b41d 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 998e70942..787e9a973 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -64,7 +64,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = -87.0 states[1] = 0.01 states[2] = 0.8 diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index fb2e5ed24..e353013d0 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index 351e9dc86..e29840b4e 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 4d2a9c43c..d5856eb24 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 8c03c4af6..77dc8431b 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index e05d29846..d2fac6dd0 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index b475ed2af..1de612165 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index f201c2cb4..2a6e2a5f2 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; constants[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index 351e9dc86..e29840b4e 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 17b950ef3..82e966ec6 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index 19f3ea08f..72adfdb45 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; constants[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index e05d29846..d2fac6dd0 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 4179fad78..b50178500 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index 1809eb460..b16f44430 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index 351e9dc86..e29840b4e 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index f9e8d5488..0341e10a4 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 900aefa1a..2f0a222f8 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index e05d29846..d2fac6dd0 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index e32e47341..0a7d4de47 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 50b5e525b..19903539f 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = -2.0; states[1] = 0.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index c97d6682e..723fd5403 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index cfe8f9dbb..a25d71bd7 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = -2.0 states[1] = 0.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 69cb46ef0..ce6518100 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = -2.0; states[1] = 0.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index 04133c21e..a929fb7cd 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index d6823483b..c86ec1bb7 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = -2.0 states[1] = 0.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 67a376b76..c1f03ce23 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; states[1] = 1.0; diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index 83e1465e4..f62cb5d15 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 3fc06a3ab..8c2596617 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 states[1] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index 988556637..3ff8890e6 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; states[1] = 1.0; diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index 351e9dc86..e29840b4e 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 825591ba2..2da518cac 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 states[1] = 1.0 diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 026a8322f..4d5fa00df 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -117,7 +117,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[0] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index c32902725..5d5754056 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index ab4381389..1b8fd4127 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -74,7 +74,7 @@ def find_root_0(voi, states, rates, variables): algebraic[0] = u[0] -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 states[1] = 0.0 constants[0] = 0.04 diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 6685a416a..27ca2adc6 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -83,7 +83,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index c32902725..5d5754056 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index d6da1199a..ef074678f 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -50,7 +50,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 states[1] = 0.0 states[2] = 0.0 diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index b25348318..167815f03 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -87,7 +87,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = constants[0]; constants[0] = 0.0; diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index b3f715a2b..25b6b8b1e 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 35bb474ab..272f8268b 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -58,7 +58,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = constants[0] constants[0] = 0.0 constants[1] = 0.75 diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 1c1f84b89..52086b8cf 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -84,7 +84,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable) +void initialiseVariables(double *constants, double *algebraic) { constants[0] = 1.1; constants[1] = 21262500.0; @@ -94,7 +94,6 @@ void initialiseVariables(double *constants, double *algebraic, ExternalVariable constants[5] = 2902500.0; constants[6] = 810000.0; constants[7] = 247140.0; - external[1] = externalVariable(variables, 1); } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 2bb86e6fb..3e9774145 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, double *algebraic, ExternalVariable externalVariable); +void initialiseVariables(double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 74427a055..f779ffb99 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -51,7 +51,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, algebraic, external_variable): +def initialise_variables(constants, algebraic): constants[0] = 1.1 constants[1] = 21262500.0 constants[2] = 150.0 @@ -60,7 +60,6 @@ def initialise_variables(constants, algebraic, external_variable): constants[5] = 2902500.0 constants[6] = 810000.0 constants[7] = 247140.0 - external[1] = external_variable(variables, 1) def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index e230aecdb..e4500b462 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = constants[0]; constants[0] = 7.0; diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index dac6bf578..ea32185a4 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 814cd74a7..539c2776c 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, algebraic): states[0] = constants[0] constants[0] = 7.0 From b51474620873b171588f5c06437a0397f365c9ea Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 16 Aug 2024 15:06:15 +0200 Subject: [PATCH 29/74] Analyser: a variable using an NLA should always be an algebraic variable. Even if the NLA equation only uses constant variables and constant values. --- src/analyser.cpp | 133 +++++++++++------- src/generator.cpp | 16 +-- .../model.dae.c | 100 ++++++------- .../model.dae.py | 100 ++++++------- 4 files changed, 189 insertions(+), 160 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index 592ef5730..468fa16f8 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -3062,6 +3062,66 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) v2aeMappings.emplace(internalEquation->mUnknownVariables.front()->mVariable, equation); } + // Start making our internal equations available through our API. + // Note: start because we need to determine the type of our equations before we can make our internal variables + // available through our API. + + std::map aie2aetMappings; + + for (const auto &internalEquation : mInternalEquations) { + // Determine whether the equation is an external one. + + auto externalEquation = true; + + for (const auto &unknownVariable : internalEquation->mUnknownVariables) { + if (!unknownVariable->mIsExternal) { + externalEquation = false; + + break; + } + } + + // Determine and keep track of the type of the equation. + + AnalyserEquation::Type type; + + if (externalEquation) { + type = AnalyserEquation::Type::EXTERNAL; + } else { + switch (internalEquation->mType) { + case AnalyserInternalEquation::Type::TRUE_CONSTANT: + type = AnalyserEquation::Type::TRUE_CONSTANT; + + break; + case AnalyserInternalEquation::Type::VARIABLE_BASED_CONSTANT: + type = AnalyserEquation::Type::VARIABLE_BASED_CONSTANT; + + break; + case AnalyserInternalEquation::Type::ODE: + type = AnalyserEquation::Type::ODE; + + break; + case AnalyserInternalEquation::Type::NLA: + type = AnalyserEquation::Type::NLA; + + break; + case AnalyserInternalEquation::Type::ALGEBRAIC: + type = AnalyserEquation::Type::ALGEBRAIC; + + break; + default: // AnalyserEquation::Type::UNKNOWN. + // The equation type is unknown, which means that it is a dummy + // equation for a true (i.e. non-computed) constant (so that it + // could have been marked as an external variable), so we skip + // it since the constant wasn't marked as an external variable. + + continue; + } + } + + aie2aetMappings.emplace(internalEquation, type); + } + // Make our internal variables available through our API. std::map aiv2avMappings; @@ -3106,17 +3166,32 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) } } - // Populate and keep track of the state/variable. + // Retrieve the equations used to compute the variable. - auto variable = AnalyserVariable::AnalyserVariableImpl::create(); AnalyserEquationPtrs equations; + auto nlaEquation = false; for (const auto &internalEquation : mInternalEquations) { if (std::find(internalEquation->mUnknownVariables.begin(), internalEquation->mUnknownVariables.end(), internalVariable) != internalEquation->mUnknownVariables.end()) { equations.push_back(aie2aeMappings[internalEquation]); + + if ((aie2aetMappings.find(internalEquation) != aie2aetMappings.end()) + && (aie2aetMappings[internalEquation] == AnalyserEquation::Type::NLA)) { + nlaEquation = true; + } } } + // Correct the type of the variable if it is a computed constant that is computed using an NLA equation. + + if ((type == AnalyserVariable::Type::COMPUTED_CONSTANT) && nlaEquation) { + type = AnalyserVariable::Type::ALGEBRAIC; + } + + // Populate and keep track of the state/variable. + + auto variable = AnalyserVariable::AnalyserVariableImpl::create(); + variable->mPimpl->populate(type, (type == AnalyserVariable::Type::STATE) ? ++stateIndex : @@ -3162,57 +3237,13 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) } } - // Make our internal equations available through our API. + // Finish making our internal equations available through our API. for (const auto &internalEquation : mInternalEquations) { - // Determine whether the equation is an external one. - - auto externalEquation = true; - - for (const auto &unknownVariable : internalEquation->mUnknownVariables) { - if (aiv2avMappings[unknownVariable]->type() != AnalyserVariable::Type::EXTERNAL) { - externalEquation = false; + // Make sure that the type of the equation is known. - break; - } - } - - // Determine the type of the equation. - - AnalyserEquation::Type type; - - if (externalEquation) { - type = AnalyserEquation::Type::EXTERNAL; - } else { - switch (internalEquation->mType) { - case AnalyserInternalEquation::Type::TRUE_CONSTANT: - type = AnalyserEquation::Type::TRUE_CONSTANT; - - break; - case AnalyserInternalEquation::Type::VARIABLE_BASED_CONSTANT: - type = AnalyserEquation::Type::VARIABLE_BASED_CONSTANT; - - break; - case AnalyserInternalEquation::Type::ODE: - type = AnalyserEquation::Type::ODE; - - break; - case AnalyserInternalEquation::Type::NLA: - type = AnalyserEquation::Type::NLA; - - break; - case AnalyserInternalEquation::Type::ALGEBRAIC: - type = AnalyserEquation::Type::ALGEBRAIC; - - break; - default: // AnalyserEquation::Type::UNKNOWN. - // The equation type is unknown, which means that it is a dummy - // equation for a true (i.e. non-computed) constant (so that it - // could have been marked as an external variable), so we skip - // it since the constant wasn't marked as an external variable. - - continue; - } + if (aie2aetMappings.find(internalEquation) == aie2aetMappings.end()) { + continue; } // Scale our internal equation's AST to take into account the fact that @@ -3223,6 +3254,8 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Manipulate the equation, if needed. + auto type = aie2aetMappings[internalEquation]; + switch (type) { case AnalyserEquation::Type::NLA: // The equation is currently of the form LHS = RHS, but we want it diff --git a/src/generator.cpp b/src/generator.cpp index 23a46e90d..9f62dfb95 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1830,15 +1830,12 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st } } - // Initialise our constants and our algebraic variables that have an - // initial value. Also use an initial guess of zero for computed - // constants and algebraic variables computed using an NLA system. - // Note: a variable which is the only unknown in an equation, but which - // is not on its own on either the LHS or RHS of that equation - // (e.g., x = y+z with x and y known and z unknown) is (currently) - // to be computed using an NLA system for which we need an initial - // guess. We use an initial guess of zero, which is fine since - // such an NLA system has only one solution. + // Initialise our constants and our algebraic variables that have an initial value. Also use an initial guess of + // zero for algebraic variables computed using an NLA system. + // Note: a variable which is the only unknown in an equation, but which is not on its own on either the LHS or + // RHS of that equation (e.g., x = y+z with x and y known and z unknown) is (currently) to be computed + // using an NLA system for which we need an initial guess. We use an initial guess of zero, which is fine + // since such an NLA system has only one solution. for (const auto &variable : variables(mModel)) { switch (variable->type()) { @@ -1846,7 +1843,6 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st methodBody += generateInitialisationCode(variable); break; - case AnalyserVariable::Type::COMPUTED_CONSTANT: case AnalyserVariable::Type::ALGEBRAIC: if (variable->initialisingVariable() != nullptr) { methodBody += generateInitialisationCode(variable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 25ffe82fe..51e1dd0e2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -10,8 +10,8 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 5; -const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_COUNT = 10; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 13; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -31,9 +31,6 @@ const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"E_L", "millivolt", "leakage_current"}, - {"E_Na", "millivolt", "sodium_channel"}, - {"E_K", "millivolt", "potassium_channel"} }; const VariableInfo ALGEBRAIC_INFO[] = { @@ -41,10 +38,13 @@ const VariableInfo ALGEBRAIC_INFO[] = { {"i_L", "microA_per_cm2", "leakage_current"}, {"i_K", "microA_per_cm2", "potassium_channel"}, {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"E_K", "millivolt", "potassium_channel"}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; @@ -163,9 +163,9 @@ void objectiveFunction2(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - computedConstants[0] = u[0]; + algebraic[4] = u[0]; - f[0] = computedConstants[0]-(constants[1]-10.613)-0.0; + f[0] = algebraic[4]-(constants[1]-10.613)-0.0; } void findRoot2(double voi, double *states, double *rates, double *variables) @@ -173,11 +173,11 @@ void findRoot2(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = external[0]; + u[0] = algebraic[4]; nlaSolve(objectiveFunction2, u, 1, &rfi); - external[0] = u[0]; + algebraic[4] = u[0]; } void objectiveFunction3(double *u, double *f, void *data) @@ -189,7 +189,7 @@ void objectiveFunction3(double *u, double *f, void *data) algebraic[1] = u[0]; - f[0] = algebraic[1]-constants[2]*(states[0]-computedConstants[0])-0.0; + f[0] = algebraic[1]-constants[2]*(states[0]-algebraic[4])-0.0; } void findRoot3(double voi, double *states, double *rates, double *variables) @@ -211,9 +211,9 @@ void objectiveFunction4(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - computedConstants[1] = u[0]; + algebraic[5] = u[0]; - f[0] = computedConstants[1]-(constants[1]-115.0)-0.0; + f[0] = algebraic[5]-(constants[1]-115.0)-0.0; } void findRoot4(double voi, double *states, double *rates, double *variables) @@ -221,11 +221,11 @@ void findRoot4(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = external[1]; + u[0] = algebraic[5]; nlaSolve(objectiveFunction4, u, 1, &rfi); - external[1] = u[0]; + algebraic[5] = u[0]; } void objectiveFunction5(double *u, double *f, void *data) @@ -237,7 +237,7 @@ void objectiveFunction5(double *u, double *f, void *data) algebraic[3] = u[0]; - f[0] = algebraic[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1])-0.0; + f[0] = algebraic[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5])-0.0; } void findRoot5(double voi, double *states, double *rates, double *variables) @@ -259,9 +259,9 @@ void objectiveFunction6(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[4] = u[0]; + algebraic[6] = u[0]; - f[0] = algebraic[4]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0; + f[0] = algebraic[6]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0; } void findRoot6(double voi, double *states, double *rates, double *variables) @@ -269,11 +269,11 @@ void findRoot6(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[4]; + u[0] = algebraic[6]; nlaSolve(objectiveFunction6, u, 1, &rfi); - algebraic[4] = u[0]; + algebraic[6] = u[0]; } void objectiveFunction7(double *u, double *f, void *data) @@ -283,9 +283,9 @@ void objectiveFunction7(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[5] = u[0]; + algebraic[7] = u[0]; - f[0] = algebraic[5]-4.0*exp(states[0]/18.0)-0.0; + f[0] = algebraic[7]-4.0*exp(states[0]/18.0)-0.0; } void findRoot7(double voi, double *states, double *rates, double *variables) @@ -293,11 +293,11 @@ void findRoot7(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[5]; + u[0] = algebraic[7]; nlaSolve(objectiveFunction7, u, 1, &rfi); - algebraic[5] = u[0]; + algebraic[7] = u[0]; } void objectiveFunction8(double *u, double *f, void *data) @@ -309,7 +309,7 @@ void objectiveFunction8(double *u, double *f, void *data) rates[2] = u[0]; - f[0] = rates[2]-(algebraic[4]*(1.0-states[2])-algebraic[5]*states[2])-0.0; + f[0] = rates[2]-(algebraic[6]*(1.0-states[2])-algebraic[7]*states[2])-0.0; } void findRoot8(double voi, double *states, double *rates, double *variables) @@ -331,9 +331,9 @@ void objectiveFunction9(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[6] = u[0]; + algebraic[8] = u[0]; - f[0] = algebraic[6]-0.07*exp(states[0]/20.0)-0.0; + f[0] = algebraic[8]-0.07*exp(states[0]/20.0)-0.0; } void findRoot9(double voi, double *states, double *rates, double *variables) @@ -341,11 +341,11 @@ void findRoot9(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[6]; + u[0] = algebraic[8]; nlaSolve(objectiveFunction9, u, 1, &rfi); - algebraic[6] = u[0]; + algebraic[8] = u[0]; } void objectiveFunction10(double *u, double *f, void *data) @@ -355,9 +355,9 @@ void objectiveFunction10(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[7] = u[0]; + algebraic[9] = u[0]; - f[0] = algebraic[7]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; + f[0] = algebraic[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; } void findRoot10(double voi, double *states, double *rates, double *variables) @@ -365,11 +365,11 @@ void findRoot10(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[7]; + u[0] = algebraic[9]; nlaSolve(objectiveFunction10, u, 1, &rfi); - algebraic[7] = u[0]; + algebraic[9] = u[0]; } void objectiveFunction11(double *u, double *f, void *data) @@ -381,7 +381,7 @@ void objectiveFunction11(double *u, double *f, void *data) rates[1] = u[0]; - f[0] = rates[1]-(algebraic[6]*(1.0-states[1])-algebraic[7]*states[1])-0.0; + f[0] = rates[1]-(algebraic[8]*(1.0-states[1])-algebraic[9]*states[1])-0.0; } void findRoot11(double voi, double *states, double *rates, double *variables) @@ -403,9 +403,9 @@ void objectiveFunction12(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - computedConstants[2] = u[0]; + algebraic[10] = u[0]; - f[0] = computedConstants[2]-(constants[1]+12.0)-0.0; + f[0] = algebraic[10]-(constants[1]+12.0)-0.0; } void findRoot12(double voi, double *states, double *rates, double *variables) @@ -413,11 +413,11 @@ void findRoot12(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = external[2]; + u[0] = algebraic[10]; nlaSolve(objectiveFunction12, u, 1, &rfi); - external[2] = u[0]; + algebraic[10] = u[0]; } void objectiveFunction13(double *u, double *f, void *data) @@ -429,7 +429,7 @@ void objectiveFunction13(double *u, double *f, void *data) algebraic[2] = u[0]; - f[0] = algebraic[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2])-0.0; + f[0] = algebraic[2]-constants[4]*pow(states[3], 4.0)*(states[0]-algebraic[10])-0.0; } void findRoot13(double voi, double *states, double *rates, double *variables) @@ -451,9 +451,9 @@ void objectiveFunction14(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[8] = u[0]; + algebraic[11] = u[0]; - f[0] = algebraic[8]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; + f[0] = algebraic[11]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; } void findRoot14(double voi, double *states, double *rates, double *variables) @@ -461,11 +461,11 @@ void findRoot14(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[8]; + u[0] = algebraic[11]; nlaSolve(objectiveFunction14, u, 1, &rfi); - algebraic[8] = u[0]; + algebraic[11] = u[0]; } void objectiveFunction15(double *u, double *f, void *data) @@ -475,9 +475,9 @@ void objectiveFunction15(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *variables = ((RootFindingInfo *) data)->variables; - algebraic[9] = u[0]; + algebraic[12] = u[0]; - f[0] = algebraic[9]-0.125*exp(states[0]/80.0)-0.0; + f[0] = algebraic[12]-0.125*exp(states[0]/80.0)-0.0; } void findRoot15(double voi, double *states, double *rates, double *variables) @@ -485,11 +485,11 @@ void findRoot15(double voi, double *states, double *rates, double *variables) RootFindingInfo rfi = { voi, states, rates, variables }; double u[1]; - u[0] = algebraic[9]; + u[0] = algebraic[12]; nlaSolve(objectiveFunction15, u, 1, &rfi); - algebraic[9] = u[0]; + algebraic[12] = u[0]; } void objectiveFunction16(double *u, double *f, void *data) @@ -501,7 +501,7 @@ void objectiveFunction16(double *u, double *f, void *data) rates[3] = u[0]; - f[0] = rates[3]-(algebraic[8]*(1.0-states[3])-algebraic[9]*states[3])-0.0; + f[0] = rates[3]-(algebraic[11]*(1.0-states[3])-algebraic[12]*states[3])-0.0; } void findRoot16(double voi, double *states, double *rates, double *variables) @@ -531,9 +531,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - computedConstants[0] = 0.0; - computedConstants[1] = 0.0; - computedConstants[2] = 0.0; algebraic[0] = 0.0; algebraic[1] = 0.0; algebraic[2] = 0.0; @@ -544,6 +541,9 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons algebraic[7] = 0.0; algebraic[8] = 0.0; algebraic[9] = 0.0; + algebraic[10] = 0.0; + algebraic[11] = 0.0; + algebraic[12] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 6a67ef421..a42be47a5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -9,8 +9,8 @@ STATE_COUNT = 4 CONSTANT_COUNT = 5 -COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_COUNT = 10 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 13 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -30,9 +30,6 @@ ] COMPUTED_CONSTANT_INFO = [ - {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, - {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, - {"name": "E_K", "units": "millivolt", "component": "potassium_channel"} ] ALGEBRAIC_INFO = [ @@ -40,10 +37,13 @@ {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] @@ -128,19 +128,19 @@ def objective_function_2(u, f, data): rates = data[2] variables = data[3] - computed_constants[0] = u[0] + algebraic[4] = u[0] - f[0] = computed_constants[0]-(constants[1]-10.613)-0.0 + f[0] = algebraic[4]-(constants[1]-10.613)-0.0 def find_root_2(voi, states, rates, variables): u = [nan]*1 - u[0] = external[0] + u[0] = algebraic[4] u = nla_solve(objective_function_2, u, 1, [voi, states, rates, variables]) - external[0] = u[0] + algebraic[4] = u[0] def objective_function_3(u, f, data): @@ -151,7 +151,7 @@ def objective_function_3(u, f, data): algebraic[1] = u[0] - f[0] = algebraic[1]-constants[2]*(states[0]-computed_constants[0])-0.0 + f[0] = algebraic[1]-constants[2]*(states[0]-algebraic[4])-0.0 def find_root_3(voi, states, rates, variables): @@ -170,19 +170,19 @@ def objective_function_4(u, f, data): rates = data[2] variables = data[3] - computed_constants[1] = u[0] + algebraic[5] = u[0] - f[0] = computed_constants[1]-(constants[1]-115.0)-0.0 + f[0] = algebraic[5]-(constants[1]-115.0)-0.0 def find_root_4(voi, states, rates, variables): u = [nan]*1 - u[0] = external[1] + u[0] = algebraic[5] u = nla_solve(objective_function_4, u, 1, [voi, states, rates, variables]) - external[1] = u[0] + algebraic[5] = u[0] def objective_function_5(u, f, data): @@ -193,7 +193,7 @@ def objective_function_5(u, f, data): algebraic[3] = u[0] - f[0] = algebraic[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1])-0.0 + f[0] = algebraic[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5])-0.0 def find_root_5(voi, states, rates, variables): @@ -212,19 +212,19 @@ def objective_function_6(u, f, data): rates = data[2] variables = data[3] - algebraic[4] = u[0] + algebraic[6] = u[0] - f[0] = algebraic[4]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0 + f[0] = algebraic[6]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0 def find_root_6(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[4] + u[0] = algebraic[6] u = nla_solve(objective_function_6, u, 1, [voi, states, rates, variables]) - algebraic[4] = u[0] + algebraic[6] = u[0] def objective_function_7(u, f, data): @@ -233,19 +233,19 @@ def objective_function_7(u, f, data): rates = data[2] variables = data[3] - algebraic[5] = u[0] + algebraic[7] = u[0] - f[0] = algebraic[5]-4.0*exp(states[0]/18.0)-0.0 + f[0] = algebraic[7]-4.0*exp(states[0]/18.0)-0.0 def find_root_7(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[5] + u[0] = algebraic[7] u = nla_solve(objective_function_7, u, 1, [voi, states, rates, variables]) - algebraic[5] = u[0] + algebraic[7] = u[0] def objective_function_8(u, f, data): @@ -256,7 +256,7 @@ def objective_function_8(u, f, data): rates[2] = u[0] - f[0] = rates[2]-(algebraic[4]*(1.0-states[2])-algebraic[5]*states[2])-0.0 + f[0] = rates[2]-(algebraic[6]*(1.0-states[2])-algebraic[7]*states[2])-0.0 def find_root_8(voi, states, rates, variables): @@ -275,19 +275,19 @@ def objective_function_9(u, f, data): rates = data[2] variables = data[3] - algebraic[6] = u[0] + algebraic[8] = u[0] - f[0] = algebraic[6]-0.07*exp(states[0]/20.0)-0.0 + f[0] = algebraic[8]-0.07*exp(states[0]/20.0)-0.0 def find_root_9(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[6] + u[0] = algebraic[8] u = nla_solve(objective_function_9, u, 1, [voi, states, rates, variables]) - algebraic[6] = u[0] + algebraic[8] = u[0] def objective_function_10(u, f, data): @@ -296,19 +296,19 @@ def objective_function_10(u, f, data): rates = data[2] variables = data[3] - algebraic[7] = u[0] + algebraic[9] = u[0] - f[0] = algebraic[7]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 + f[0] = algebraic[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 def find_root_10(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[7] + u[0] = algebraic[9] u = nla_solve(objective_function_10, u, 1, [voi, states, rates, variables]) - algebraic[7] = u[0] + algebraic[9] = u[0] def objective_function_11(u, f, data): @@ -319,7 +319,7 @@ def objective_function_11(u, f, data): rates[1] = u[0] - f[0] = rates[1]-(algebraic[6]*(1.0-states[1])-algebraic[7]*states[1])-0.0 + f[0] = rates[1]-(algebraic[8]*(1.0-states[1])-algebraic[9]*states[1])-0.0 def find_root_11(voi, states, rates, variables): @@ -338,19 +338,19 @@ def objective_function_12(u, f, data): rates = data[2] variables = data[3] - computed_constants[2] = u[0] + algebraic[10] = u[0] - f[0] = computed_constants[2]-(constants[1]+12.0)-0.0 + f[0] = algebraic[10]-(constants[1]+12.0)-0.0 def find_root_12(voi, states, rates, variables): u = [nan]*1 - u[0] = external[2] + u[0] = algebraic[10] u = nla_solve(objective_function_12, u, 1, [voi, states, rates, variables]) - external[2] = u[0] + algebraic[10] = u[0] def objective_function_13(u, f, data): @@ -361,7 +361,7 @@ def objective_function_13(u, f, data): algebraic[2] = u[0] - f[0] = algebraic[2]-constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2])-0.0 + f[0] = algebraic[2]-constants[4]*pow(states[3], 4.0)*(states[0]-algebraic[10])-0.0 def find_root_13(voi, states, rates, variables): @@ -380,19 +380,19 @@ def objective_function_14(u, f, data): rates = data[2] variables = data[3] - algebraic[8] = u[0] + algebraic[11] = u[0] - f[0] = algebraic[8]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 + f[0] = algebraic[11]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 def find_root_14(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[8] + u[0] = algebraic[11] u = nla_solve(objective_function_14, u, 1, [voi, states, rates, variables]) - algebraic[8] = u[0] + algebraic[11] = u[0] def objective_function_15(u, f, data): @@ -401,19 +401,19 @@ def objective_function_15(u, f, data): rates = data[2] variables = data[3] - algebraic[9] = u[0] + algebraic[12] = u[0] - f[0] = algebraic[9]-0.125*exp(states[0]/80.0)-0.0 + f[0] = algebraic[12]-0.125*exp(states[0]/80.0)-0.0 def find_root_15(voi, states, rates, variables): u = [nan]*1 - u[0] = algebraic[9] + u[0] = algebraic[12] u = nla_solve(objective_function_15, u, 1, [voi, states, rates, variables]) - algebraic[9] = u[0] + algebraic[12] = u[0] def objective_function_16(u, f, data): @@ -424,7 +424,7 @@ def objective_function_16(u, f, data): rates[3] = u[0] - f[0] = rates[3]-(algebraic[8]*(1.0-states[3])-algebraic[9]*states[3])-0.0 + f[0] = rates[3]-(algebraic[11]*(1.0-states[3])-algebraic[12]*states[3])-0.0 def find_root_16(voi, states, rates, variables): @@ -451,9 +451,6 @@ def initialise_variables(voi, states, rates, constants, algebraic): constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - computed_constants[0] = 0.0 - computed_constants[1] = 0.0 - computed_constants[2] = 0.0 algebraic[0] = 0.0 algebraic[1] = 0.0 algebraic[2] = 0.0 @@ -464,6 +461,9 @@ def initialise_variables(voi, states, rates, constants, algebraic): algebraic[7] = 0.0 algebraic[8] = 0.0 algebraic[9] = 0.0 + algebraic[10] = 0.0 + algebraic[11] = 0.0 + algebraic[12] = 0.0 def compute_computed_constants(constants, computed_constants): From 153b4b50d25b4159d310e45cfdb7a386078d1e6f Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 16 Aug 2024 18:13:10 +0200 Subject: [PATCH 30/74] Analyser: some minor cleaning up. Constants are indexed using makeConstant(). --- src/analyser.cpp | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index 468fa16f8..d5758379d 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -208,8 +208,7 @@ struct AnalyserInternalEquation bool variableOnRhs(const AnalyserInternalVariablePtr &variable); bool variableOnLhsOrRhs(const AnalyserInternalVariablePtr &variable); - bool check(const AnalyserModelPtr &model, size_t &stateIndex, size_t &constantIndex, - size_t &computedConstantIndex, size_t &algebraicIndex, bool checkNlaSystems); + bool check(const AnalyserModelPtr &model, size_t &stateIndex, size_t &computedConstantIndex, size_t &algebraicIndex, bool checkNlaSystems); }; AnalyserInternalEquationPtr AnalyserInternalEquation::create(const ComponentPtr &component) @@ -322,9 +321,7 @@ bool AnalyserInternalEquation::variableOnLhsOrRhs(const AnalyserInternalVariable } bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, - size_t &stateIndex, size_t &constantIndex, - size_t &computedConstantIndex, size_t &algebraicIndex, - bool checkNlaSystems) + size_t &stateIndex, size_t &computedConstantIndex, size_t &algebraicIndex, bool checkNlaSystems) { // Nothing to check if the equation has a known type. @@ -439,8 +436,6 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, case AnalyserInternalVariable::Type::ALGEBRAIC: variable->mIndex = (variable->mType == AnalyserInternalVariable::Type::STATE) ? ++stateIndex : - (variable->mType == AnalyserInternalVariable::Type::CONSTANT) ? - ++constantIndex : ((variable->mType == AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT) || (variable->mType == AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT)) ? ++computedConstantIndex : @@ -2766,8 +2761,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) relevantCheck = false; for (const auto &internalEquation : mInternalEquations) { - relevantCheck = internalEquation->check(mModel, stateIndex, constantIndex, computedConstantIndex, - algebraicIndex, checkNlaSystems) + relevantCheck = internalEquation->check(mModel, stateIndex, computedConstantIndex, algebraicIndex, checkNlaSystems) || relevantCheck; } From 19126a88da358d15cac81c0eb830de09db77d52a Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 16 Aug 2024 18:29:05 +0200 Subject: [PATCH 31/74] Analyser: properly set the index of external variables. --- src/analyser.cpp | 5 +- .../model.external.c | 4 +- .../model.external.py | 4 +- .../cell_geometry_model/model.external.c | 6 +- .../cell_geometry_model/model.external.py | 6 +- .../model.algebraic.c | 44 +++++++------- .../model.algebraic.py | 44 +++++++------- .../model.computed.constant.c | 38 ++++++------ .../model.computed.constant.py | 38 ++++++------ .../model.constant.c | 36 ++++++------ .../model.constant.py | 36 ++++++------ .../model.dependent.algebraic.c | 44 +++++++------- .../model.dependent.algebraic.py | 44 +++++++------- .../model.dependent.computed.constant.c | 58 +++++++++---------- .../model.dependent.computed.constant.py | 58 +++++++++---------- .../model.dependent.constant.c | 44 +++++++------- .../model.dependent.constant.py | 44 +++++++------- .../model.dependent.state.c | 26 ++++----- .../model.dependent.state.py | 26 ++++----- .../model.external.c | 28 ++++----- .../model.external.py | 28 ++++----- .../model.state.c | 32 +++++----- .../model.state.py | 32 +++++----- .../model.c | 4 +- .../model.py | 4 +- 25 files changed, 368 insertions(+), 365 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index d5758379d..8670ec392 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -3120,6 +3120,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) std::map aiv2avMappings; std::map v2avMappings; + auto externalIndex = MAX_SIZE_T; stateIndex = MAX_SIZE_T; constantIndex = MAX_SIZE_T; @@ -3193,7 +3194,9 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) ++constantIndex : (type == AnalyserVariable::Type::COMPUTED_CONSTANT) ? ++computedConstantIndex : - ++algebraicIndex, + (type == AnalyserVariable::Type::ALGEBRAIC) ? + ++algebraicIndex : + ++externalIndex, (type == AnalyserVariable::Type::EXTERNAL) ? nullptr : internalVariable->mInitialisingVariable, diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index cae10b971..5cea89727 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -86,6 +86,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[1] = externalVariable(variables, 1); - algebraic[0] = external[1]; + external[0] = externalVariable(variables, 0); + algebraic[0] = external[0]; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 293eda06d..8ce48759d 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -52,5 +52,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - external[1] = external_variable(variables, 1) - algebraic[0] = external[1] + external[0] = external_variable(variables, 0) + algebraic[0] = external[0] diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index d20c18769..c4c33c7c0 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -88,8 +88,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { + external[0] = externalVariable(variables, 0); external[1] = externalVariable(variables, 1); - external[2] = externalVariable(variables, 2); - algebraic[0] = 1000.0*3.14*external[2]*external[2]*external[1]; - algebraic[3] = 0.02*algebraic[0]; + algebraic[0] = 1000.0*3.14*external[1]*external[1]*external[0]; + algebraic[1] = 0.02*algebraic[0]; } diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 734dbc14e..8f9555d5c 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -54,7 +54,7 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): + external[0] = external_variable(variables, 0) external[1] = external_variable(variables, 1) - external[2] = external_variable(variables, 2) - algebraic[0] = 1000.0*3.14*external[2]*external[2]*external[1] - algebraic[3] = 0.02*algebraic[0] + algebraic[0] = 1000.0*3.14*external[1]*external[1]*external[0] + algebraic[1] = 0.02*algebraic[0] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index d81cafe4e..3ca0c5371 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -136,31 +136,31 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-external[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[5] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; - algebraic[6] = 0.07*exp(states[0]/20.0); - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[9] = 0.125*exp(states[0]/80.0); - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; + algebraic[0] = constants[2]*(states[0]-computedConstants[0]); + algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-external[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[4] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2]; + algebraic[5] = 0.07*exp(states[0]/20.0); + algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1]; + algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[8] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[7]*(1.0-states[3])-algebraic[8]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[5] = 4.0*exp(states[0]/18.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[9] = 0.125*exp(states[0]/80.0); + algebraic[0] = constants[2]*(states[0]-computedConstants[0]); + algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[4] = 4.0*exp(states[0]/18.0); + algebraic[5] = 0.07*exp(states[0]/20.0); + algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[8] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index ddf22acb1..bbc403eae 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -105,29 +105,29 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-external[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[5] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] - algebraic[6] = 0.07*exp(states[0]/20.0) - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[9] = 0.125*exp(states[0]/80.0) - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] + algebraic[0] = constants[2]*(states[0]-computed_constants[0]) + algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-external[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0] + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[4] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2] + algebraic[5] = 0.07*exp(states[0]/20.0) + algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1] + algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[8] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[7]*(1.0-states[3])-algebraic[8]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[5] = 4.0*exp(states[0]/18.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[9] = 0.125*exp(states[0]/80.0) + algebraic[0] = constants[2]*(states[0]-computed_constants[0]) + algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[4] = 4.0*exp(states[0]/18.0) + algebraic[5] = 0.07*exp(states[0]/20.0) + algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[8] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 42fbe0421..9de4002c1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -135,32 +135,32 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - external[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[1] = constants[2]*(states[0]-external[4]); + external[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[2]*(states[0]-external[0]); algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[6] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[5]*(1.0-states[2])-algebraic[6]*states[2]; - algebraic[7] = 0.07*exp(states[0]/20.0); - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1]; - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[10] = 0.125*exp(states[0]/80.0); - rates[3] = algebraic[9]*(1.0-states[3])-algebraic[10]*states[3]; + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[1] = constants[2]*(states[0]-external[4]); + external[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[2]*(states[0]-external[0]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); - algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[6] = 4.0*exp(states[0]/18.0); - algebraic[7] = 0.07*exp(states[0]/20.0); - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[10] = 0.125*exp(states[0]/80.0); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index ebabb1f34..a9fd749a9 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -104,30 +104,30 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external[4] = external_variable(voi, states, rates, variables, 4) - algebraic[1] = constants[2]*(states[0]-external[4]) + external[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[2]*(states[0]-external[0]) algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[6] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[5]*(1.0-states[2])-algebraic[6]*states[2] - algebraic[7] = 0.07*exp(states[0]/20.0) - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1] - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[10] = 0.125*exp(states[0]/80.0) - rates[3] = algebraic[9]*(1.0-states[3])-algebraic[10]*states[3] + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[4] = external_variable(voi, states, rates, variables, 4) - algebraic[1] = constants[2]*(states[0]-external[4]) + external[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[2]*(states[0]-external[0]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) - algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[6] = 4.0*exp(states[0]/18.0) - algebraic[7] = 0.07*exp(states[0]/20.0) - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[10] = 0.125*exp(states[0]/80.0) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 48d149994..83398ea28 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -135,32 +135,32 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - external[4] = externalVariable(voi, states, rates, variables, 4); + external[0] = externalVariable(voi, states, rates, variables, 0); algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[4]; - algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[6] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[5]*(1.0-states[2])-algebraic[6]*states[2]; - algebraic[7] = 0.07*exp(states[0]/20.0); - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1]; - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[10] = 0.125*exp(states[0]/80.0); - rates[3] = algebraic[9]*(1.0-states[3])-algebraic[10]*states[3]; + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[0]; + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[6] = 4.0*exp(states[0]/18.0); - algebraic[7] = 0.07*exp(states[0]/20.0); - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[10] = 0.125*exp(states[0]/80.0); - external[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); + external[0] = externalVariable(voi, states, rates, variables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 82efd710e..e5b794335 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -104,30 +104,30 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external[4] = external_variable(voi, states, rates, variables, 4) + external[0] = external_variable(voi, states, rates, variables, 0) algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[4] - algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[6] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[5]*(1.0-states[2])-algebraic[6]*states[2] - algebraic[7] = 0.07*exp(states[0]/20.0) - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1] - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[10] = 0.125*exp(states[0]/80.0) - rates[3] = algebraic[9]*(1.0-states[3])-algebraic[10]*states[3] + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[0] + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[6] = 4.0*exp(states[0]/18.0) - algebraic[7] = 0.07*exp(states[0]/20.0) - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[10] = 0.125*exp(states[0]/80.0) - external[4] = external_variable(voi, states, rates, variables, 4) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) + external[0] = external_variable(voi, states, rates, variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 6631f821e..63f4f0572 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -135,32 +135,32 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[9] = externalVariable(voi, states, rates, variables, 9); + external[1] = externalVariable(voi, states, rates, variables, 1); external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-external[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[5] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; - algebraic[6] = 0.07*exp(states[0]/20.0); - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = algebraic[8]*(1.0-states[3])-external[9]*states[3]; + algebraic[0] = constants[2]*(states[0]-computedConstants[0]); + algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-external[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[4] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2]; + algebraic[5] = 0.07*exp(states[0]/20.0); + algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1]; + algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraic[7]*(1.0-states[3])-external[1]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[9] = externalVariable(voi, states, rates, variables, 9); + external[1] = externalVariable(voi, states, rates, variables, 1); external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[5] = 4.0*exp(states[0]/18.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[0] = constants[2]*(states[0]-computedConstants[0]); + algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[4] = 4.0*exp(states[0]/18.0); + algebraic[5] = 0.07*exp(states[0]/20.0); + algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 69623430c..e78d84cca 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -104,30 +104,30 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[9] = external_variable(voi, states, rates, variables, 9) + external[1] = external_variable(voi, states, rates, variables, 1) external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-external[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[5] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] - algebraic[6] = 0.07*exp(states[0]/20.0) - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = algebraic[8]*(1.0-states[3])-external[9]*states[3] + algebraic[0] = constants[2]*(states[0]-computed_constants[0]) + algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-external[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0] + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[4] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2] + algebraic[5] = 0.07*exp(states[0]/20.0) + algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1] + algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraic[7]*(1.0-states[3])-external[1]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[9] = external_variable(voi, states, rates, variables, 9) + external[1] = external_variable(voi, states, rates, variables, 1) external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[5] = 4.0*exp(states[0]/18.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[0] = constants[2]*(states[0]-computed_constants[0]) + algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[4] = 4.0*exp(states[0]/18.0) + algebraic[5] = 0.07*exp(states[0]/20.0) + algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index a51d46112..1763e10c0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -132,38 +132,38 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - external[11] = externalVariable(voi, states, rates, variables, 11); - external[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[5] = external[4]-10.613; - algebraic[1] = constants[1]*(states[0]-algebraic[5]); - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[11]); - algebraic[6] = external[4]-115.0; - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]); + external[1] = externalVariable(voi, states, rates, variables, 1); + external[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[4] = external[0]-10.613; + algebraic[1] = constants[1]*(states[0]-algebraic[4]); + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[1]); + algebraic[5] = external[0]-115.0; + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[8] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[7]*(1.0-states[2])-algebraic[8]*states[2]; - algebraic[9] = 0.07*exp(states[0]/20.0); - algebraic[10] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[9]*(1.0-states[1])-algebraic[10]*states[1]; - algebraic[12] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[13] = 0.125*exp(states[0]/80.0); - rates[3] = algebraic[12]*(1.0-states[3])-algebraic[13]*states[3]; + algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[7] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2]; + algebraic[8] = 0.07*exp(states[0]/20.0); + algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1]; + algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[11] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[11] = externalVariable(voi, states, rates, variables, 11); - external[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[5] = external[4]-10.613; - algebraic[1] = constants[1]*(states[0]-algebraic[5]); - algebraic[6] = external[4]-115.0; - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]); - algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[8] = 4.0*exp(states[0]/18.0); - algebraic[9] = 0.07*exp(states[0]/20.0); - algebraic[10] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[11]); - algebraic[12] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[13] = 0.125*exp(states[0]/80.0); + external[1] = externalVariable(voi, states, rates, variables, 1); + external[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[4] = external[0]-10.613; + algebraic[1] = constants[1]*(states[0]-algebraic[4]); + algebraic[5] = external[0]-115.0; + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]); + algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[7] = 4.0*exp(states[0]/18.0); + algebraic[8] = 0.07*exp(states[0]/20.0); + algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[1]); + algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[11] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 4dd723021..2ff358773 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -102,36 +102,36 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external[11] = external_variable(voi, states, rates, variables, 11) - external[4] = external_variable(voi, states, rates, variables, 4) - algebraic[5] = external[4]-10.613 - algebraic[1] = constants[1]*(states[0]-algebraic[5]) - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[11]) - algebraic[6] = external[4]-115.0 - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]) + external[1] = external_variable(voi, states, rates, variables, 1) + external[0] = external_variable(voi, states, rates, variables, 0) + algebraic[4] = external[0]-10.613 + algebraic[1] = constants[1]*(states[0]-algebraic[4]) + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[1]) + algebraic[5] = external[0]-115.0 + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[8] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[7]*(1.0-states[2])-algebraic[8]*states[2] - algebraic[9] = 0.07*exp(states[0]/20.0) - algebraic[10] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[9]*(1.0-states[1])-algebraic[10]*states[1] - algebraic[12] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[13] = 0.125*exp(states[0]/80.0) - rates[3] = algebraic[12]*(1.0-states[3])-algebraic[13]*states[3] + algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[7] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2] + algebraic[8] = 0.07*exp(states[0]/20.0) + algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1] + algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[11] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[11] = external_variable(voi, states, rates, variables, 11) - external[4] = external_variable(voi, states, rates, variables, 4) - algebraic[5] = external[4]-10.613 - algebraic[1] = constants[1]*(states[0]-algebraic[5]) - algebraic[6] = external[4]-115.0 - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[6]) - algebraic[7] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[8] = 4.0*exp(states[0]/18.0) - algebraic[9] = 0.07*exp(states[0]/20.0) - algebraic[10] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[11]) - algebraic[12] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[13] = 0.125*exp(states[0]/80.0) + external[1] = external_variable(voi, states, rates, variables, 1) + external[0] = external_variable(voi, states, rates, variables, 0) + algebraic[4] = external[0]-10.613 + algebraic[1] = constants[1]*(states[0]-algebraic[4]) + algebraic[5] = external[0]-115.0 + algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]) + algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[7] = 4.0*exp(states[0]/18.0) + algebraic[8] = 0.07*exp(states[0]/20.0) + algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[1]) + algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[11] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 004ed3c37..bf11e3c35 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -134,34 +134,34 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - external[5] = externalVariable(voi, states, rates, variables, 5); - external[4] = externalVariable(voi, states, rates, variables, 4); + external[1] = externalVariable(voi, states, rates, variables, 1); + external[0] = externalVariable(voi, states, rates, variables, 0); algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[3] = external[5]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[4]; - algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[7] = 4.0*exp(states[0]/18.0); - rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2]; - algebraic[8] = 0.07*exp(states[0]/20.0); - algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1]; - algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[11] = 0.125*exp(states[0]/80.0); - rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3]; + algebraic[3] = external[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[0]; + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = constants[1]*(states[0]-computedConstants[0]); - external[5] = externalVariable(voi, states, rates, variables, 5); - algebraic[3] = external[5]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[7] = 4.0*exp(states[0]/18.0); - algebraic[8] = 0.07*exp(states[0]/20.0); - algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + external[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[3] = external[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[11] = 0.125*exp(states[0]/80.0); - external[4] = externalVariable(voi, states, rates, variables, 4); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); + external[0] = externalVariable(voi, states, rates, variables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 05478b926..523a74854 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -103,32 +103,32 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external[5] = external_variable(voi, states, rates, variables, 5) - external[4] = external_variable(voi, states, rates, variables, 4) + external[1] = external_variable(voi, states, rates, variables, 1) + external[0] = external_variable(voi, states, rates, variables, 0) algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[3] = external[5]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[4] - algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[7] = 4.0*exp(states[0]/18.0) - rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2] - algebraic[8] = 0.07*exp(states[0]/20.0) - algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1] - algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[11] = 0.125*exp(states[0]/80.0) - rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3] + algebraic[3] = external[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[0] + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) + rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[1] = constants[1]*(states[0]-computed_constants[0]) - external[5] = external_variable(voi, states, rates, variables, 5) - algebraic[3] = external[5]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[7] = 4.0*exp(states[0]/18.0) - algebraic[8] = 0.07*exp(states[0]/20.0) - algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + external[1] = external_variable(voi, states, rates, variables, 1) + algebraic[3] = external[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[11] = 0.125*exp(states[0]/80.0) - external[4] = external_variable(voi, states, rates, variables, 4) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) + external[0] = external_variable(voi, states, rates, variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index c5a4fdcb3..e9bb071d9 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -133,23 +133,23 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[8] = 0.07*exp(external[1]/20.0); - algebraic[9] = 1.0/(exp((external[1]+30.0)/10.0)+1.0); - rates[0] = algebraic[8]*(1.0-states[0])-algebraic[9]*states[0]; - algebraic[10] = 0.01*(external[1]+10.0)/(exp((external[1]+10.0)/10.0)-1.0); - algebraic[11] = 0.125*exp(external[1]/80.0); - rates[1] = algebraic[10]*(1.0-states[1])-algebraic[11]*states[1]; + external[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[6] = 0.07*exp(external[0]/20.0); + algebraic[7] = 1.0/(exp((external[0]+30.0)/10.0)+1.0); + rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0]; + algebraic[8] = 0.01*(external[0]+10.0)/(exp((external[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(external[0]/80.0); + rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + external[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[2]*(external[0]-computedConstants[0]); external[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[2] = constants[2]*(external[1]-computedConstants[0]); - external[5] = externalVariable(voi, states, rates, variables, 5); - algebraic[4] = constants[3]*pow(external[5], 3.0)*states[0]*(external[1]-computedConstants[1]); - algebraic[6] = 0.1*(external[1]+25.0)/(exp((external[1]+25.0)/10.0)-1.0); - algebraic[7] = 4.0*exp(external[1]/18.0); - algebraic[3] = constants[4]*pow(states[1], 4.0)*(external[1]-computedConstants[2]); + algebraic[3] = constants[3]*pow(external[1], 3.0)*states[0]*(external[0]-computedConstants[1]); + algebraic[4] = 0.1*(external[0]+25.0)/(exp((external[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(external[0]/18.0); + algebraic[2] = constants[4]*pow(states[1], 4.0)*(external[0]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index f02d4bbc1..f4e175bb2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -102,21 +102,21 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[1] = external_variable(voi, states, rates, variables, 1) - algebraic[8] = 0.07*exp(external[1]/20.0) - algebraic[9] = 1.0/(exp((external[1]+30.0)/10.0)+1.0) - rates[0] = algebraic[8]*(1.0-states[0])-algebraic[9]*states[0] - algebraic[10] = 0.01*(external[1]+10.0)/(exp((external[1]+10.0)/10.0)-1.0) - algebraic[11] = 0.125*exp(external[1]/80.0) - rates[1] = algebraic[10]*(1.0-states[1])-algebraic[11]*states[1] + external[0] = external_variable(voi, states, rates, variables, 0) + algebraic[6] = 0.07*exp(external[0]/20.0) + algebraic[7] = 1.0/(exp((external[0]+30.0)/10.0)+1.0) + rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0] + algebraic[8] = 0.01*(external[0]+10.0)/(exp((external[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(external[0]/80.0) + rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + external[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[2]*(external[0]-computed_constants[0]) external[1] = external_variable(voi, states, rates, variables, 1) - algebraic[2] = constants[2]*(external[1]-computed_constants[0]) - external[5] = external_variable(voi, states, rates, variables, 5) - algebraic[4] = constants[3]*pow(external[5], 3.0)*states[0]*(external[1]-computed_constants[1]) - algebraic[6] = 0.1*(external[1]+25.0)/(exp((external[1]+25.0)/10.0)-1.0) - algebraic[7] = 4.0*exp(external[1]/18.0) - algebraic[3] = constants[4]*pow(states[1], 4.0)*(external[1]-computed_constants[2]) + algebraic[3] = constants[3]*pow(external[1], 3.0)*states[0]*(external[0]-computed_constants[1]) + algebraic[4] = 0.1*(external[0]+25.0)/(exp((external[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(external[0]/18.0) + algebraic[2] = constants[4]*pow(states[1], 4.0)*(external[0]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 968d381c8..d23067e7b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -134,24 +134,24 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[5] = 0.1*(external[1]+25.0)/(exp((external[1]+25.0)/10.0)-1.0); - algebraic[6] = 4.0*exp(external[1]/18.0); - rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1]; - algebraic[7] = 0.07*exp(external[1]/20.0); - algebraic[8] = 1.0/(exp((external[1]+30.0)/10.0)+1.0); - rates[0] = algebraic[7]*(1.0-states[0])-algebraic[8]*states[0]; - external[9] = externalVariable(voi, states, rates, variables, 9); - algebraic[10] = 0.125*exp(external[1]/80.0); - rates[2] = external[9]*(1.0-states[2])-algebraic[10]*states[2]; + external[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[3] = 0.1*(external[0]+25.0)/(exp((external[0]+25.0)/10.0)-1.0); + algebraic[4] = 4.0*exp(external[0]/18.0); + rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1]; + algebraic[5] = 0.07*exp(external[0]/20.0); + algebraic[6] = 1.0/(exp((external[0]+30.0)/10.0)+1.0); + rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0]; + external[2] = externalVariable(voi, states, rates, variables, 2); + algebraic[7] = 0.125*exp(external[0]/80.0); + rates[2] = external[2]*(1.0-states[2])-algebraic[7]*states[2]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + external[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[2]*(external[0]-computedConstants[0]); + external[2] = externalVariable(voi, states, rates, variables, 2); external[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[2] = constants[2]*(external[1]-computedConstants[0]); - external[9] = externalVariable(voi, states, rates, variables, 9); - external[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[3] = constants[4]*pow(states[2], 4.0)*(external[1]-computedConstants[2]); + algebraic[2] = constants[4]*pow(states[2], 4.0)*(external[0]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index d533782ea..7e7ce5804 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -103,22 +103,22 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[1] = external_variable(voi, states, rates, variables, 1) - algebraic[5] = 0.1*(external[1]+25.0)/(exp((external[1]+25.0)/10.0)-1.0) - algebraic[6] = 4.0*exp(external[1]/18.0) - rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1] - algebraic[7] = 0.07*exp(external[1]/20.0) - algebraic[8] = 1.0/(exp((external[1]+30.0)/10.0)+1.0) - rates[0] = algebraic[7]*(1.0-states[0])-algebraic[8]*states[0] - external[9] = external_variable(voi, states, rates, variables, 9) - algebraic[10] = 0.125*exp(external[1]/80.0) - rates[2] = external[9]*(1.0-states[2])-algebraic[10]*states[2] + external[0] = external_variable(voi, states, rates, variables, 0) + algebraic[3] = 0.1*(external[0]+25.0)/(exp((external[0]+25.0)/10.0)-1.0) + algebraic[4] = 4.0*exp(external[0]/18.0) + rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1] + algebraic[5] = 0.07*exp(external[0]/20.0) + algebraic[6] = 1.0/(exp((external[0]+30.0)/10.0)+1.0) + rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0] + external[2] = external_variable(voi, states, rates, variables, 2) + algebraic[7] = 0.125*exp(external[0]/80.0) + rates[2] = external[2]*(1.0-states[2])-algebraic[7]*states[2] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + external[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[2]*(external[0]-computed_constants[0]) + external[2] = external_variable(voi, states, rates, variables, 2) external[1] = external_variable(voi, states, rates, variables, 1) - algebraic[2] = constants[2]*(external[1]-computed_constants[0]) - external[9] = external_variable(voi, states, rates, variables, 9) - external[4] = external_variable(voi, states, rates, variables, 4) - algebraic[3] = constants[4]*pow(states[2], 4.0)*(external[1]-computed_constants[2]) + algebraic[2] = constants[4]*pow(states[2], 4.0)*(external[0]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 64e677b50..fb03fdd45 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -137,27 +137,27 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraic[1] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); - external[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[3] = constants[3]*pow(external[4], 3.0)*states[1]*(states[0]-computedConstants[1]); + external[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[3] = constants[3]*pow(external[0], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[7] = 0.07*exp(states[0]/20.0); - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1]; - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[10] = 0.125*exp(states[0]/80.0); - rates[2] = algebraic[9]*(1.0-states[2])-algebraic[10]*states[2]; + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); + rates[2] = algebraic[8]*(1.0-states[2])-algebraic[9]*states[2]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - external[4] = externalVariable(voi, states, rates, variables, 4); - algebraic[3] = constants[3]*pow(external[4], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[6] = 4.0*exp(states[0]/18.0); - algebraic[7] = 0.07*exp(states[0]/20.0); - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + external[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[3] = constants[3]*pow(external[0], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(states[0]/18.0); + algebraic[6] = 0.07*exp(states[0]/20.0); + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[10] = 0.125*exp(states[0]/80.0); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index bd4d565ed..19e213325 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -106,25 +106,25 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic[1] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) - external[4] = external_variable(voi, states, rates, variables, 4) - algebraic[3] = constants[3]*pow(external[4], 3.0)*states[1]*(states[0]-computed_constants[1]) + external[0] = external_variable(voi, states, rates, variables, 0) + algebraic[3] = constants[3]*pow(external[0], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[7] = 0.07*exp(states[0]/20.0) - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - rates[1] = algebraic[7]*(1.0-states[1])-algebraic[8]*states[1] - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[10] = 0.125*exp(states[0]/80.0) - rates[2] = algebraic[9]*(1.0-states[2])-algebraic[10]*states[2] + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) + rates[2] = algebraic[8]*(1.0-states[2])-algebraic[9]*states[2] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - external[4] = external_variable(voi, states, rates, variables, 4) - algebraic[3] = constants[3]*pow(external[4], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[6] = 4.0*exp(states[0]/18.0) - algebraic[7] = 0.07*exp(states[0]/20.0) - algebraic[8] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + external[0] = external_variable(voi, states, rates, variables, 0) + algebraic[3] = constants[3]*pow(external[0], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(states[0]/18.0) + algebraic[6] = 0.07*exp(states[0]/20.0) + algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) - algebraic[9] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[10] = 0.125*exp(states[0]/80.0) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 52086b8cf..2eecb84e5 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -102,6 +102,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[1] = externalVariable(variables, 1); - algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+external[1]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]); + external[0] = externalVariable(variables, 0); + algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+external[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]); } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index f779ffb99..1d02c1f0b 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -67,5 +67,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - external[1] = external_variable(variables, 1) - algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+external[1]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) + external[0] = external_variable(variables, 0) + algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+external[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) From 841c6760775bb44a20aa52525b9564974841558b Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 16 Aug 2024 19:04:43 +0200 Subject: [PATCH 32/74] Analyser: put some struct/class definitions in a corresponding private header. --- src/analyser.cpp | 256 +-------------------------------------------- src/analyser_p.h | 266 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 267 insertions(+), 255 deletions(-) create mode 100644 src/analyser_p.h diff --git a/src/analyser.cpp b/src/analyser.cpp index 8670ec392..a3a345735 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -24,85 +24,20 @@ limitations under the License. #include #include "libcellml/analyserequation.h" -#include "libcellml/analyserequationast.h" #include "libcellml/analyserexternalvariable.h" -#include "libcellml/analysermodel.h" -#include "libcellml/analyservariable.h" -#include "libcellml/component.h" -#include "libcellml/generator.h" #include "libcellml/generatorprofile.h" -#include "libcellml/model.h" -#include "libcellml/units.h" #include "libcellml/validator.h" -#include "libcellml/variable.h" +#include "analyser_p.h" #include "analyserequation_p.h" #include "analyserequationast_p.h" -#include "analysermodel_p.h" #include "analyservariable_p.h" -#include "anycellmlelement_p.h" #include "commonutils.h" #include "generator_p.h" -#include "issue_p.h" -#include "logger_p.h" -#include "utilities.h" -#include "xmldoc.h" #include "xmlutils.h" -#include "libcellml/undefines.h" - namespace libcellml { -struct AnalyserInternalEquation; -struct AnalyserInternalVariable; - -using AnalyserInternalEquationWeakPtr = std::weak_ptr; -using AnalyserInternalEquationPtr = std::shared_ptr; -using AnalyserInternalVariablePtr = std::shared_ptr; - -using AnalyserInternalEquationWeakPtrs = std::vector; -using AnalyserInternalEquationPtrs = std::vector; -using AnalyserInternalVariablePtrs = std::vector; - -using AnalyserEquationPtrs = std::vector; -using AnalyserVariablePtrs = std::vector; -using AnalyserExternalVariablePtrs = std::vector; - -struct AnalyserInternalVariable -{ - enum struct Type - { - UNKNOWN, - SHOULD_BE_STATE, - INITIALISED, - VARIABLE_OF_INTEGRATION, - STATE, - CONSTANT, - COMPUTED_TRUE_CONSTANT, - COMPUTED_VARIABLE_BASED_CONSTANT, - INITIALISED_ALGEBRAIC, - ALGEBRAIC, - OVERCONSTRAINED - }; - - size_t mIndex = MAX_SIZE_T; - Type mType = Type::UNKNOWN; - bool mIsExternal = false; - - VariablePtr mInitialisingVariable; - VariablePtr mVariable; - VariablePtrs mDependencies; - - static AnalyserInternalVariablePtr create(const VariablePtr &variable); - - void setVariable(const VariablePtr &variable, - bool checkInitialValue = true); - - void makeVoi(); - void makeState(); - void makeConstant(size_t &index); -}; - AnalyserInternalVariablePtr AnalyserInternalVariable::create(const VariablePtr &variable) { auto res = AnalyserInternalVariablePtr {new AnalyserInternalVariable {}}; @@ -155,62 +90,6 @@ void AnalyserInternalVariable::makeConstant(size_t &index) mType = Type::CONSTANT; } -struct AnalyserInternalEquation -{ - enum struct Type - { - UNKNOWN, - TRUE_CONSTANT, - VARIABLE_BASED_CONSTANT, - ODE, - NLA, - ALGEBRAIC - }; - - Type mType = Type::UNKNOWN; - - VariablePtrs mDependencies; - - AnalyserEquationAstPtr mAst; - - ComponentPtr mComponent; - - AnalyserInternalVariablePtrs mVariables; - AnalyserInternalVariablePtrs mOdeVariables; - AnalyserInternalVariablePtrs mAllVariables; - AnalyserInternalVariablePtrs mUnknownVariables; - - size_t mNlaSystemIndex = MAX_SIZE_T; - AnalyserInternalEquationWeakPtrs mNlaSiblings; - - bool mComputedTrueConstant = true; - bool mComputedVariableBasedConstant = true; - - static AnalyserInternalEquationPtr create(const ComponentPtr &component); - static AnalyserInternalEquationPtr create(const AnalyserInternalVariablePtr &variable); - - void addVariable(const AnalyserInternalVariablePtr &variable); - void addOdeVariable(const AnalyserInternalVariablePtr &odeVariable); - - static bool isKnownVariable(const AnalyserInternalVariablePtr &variable); - static bool isKnownOdeVariable(const AnalyserInternalVariablePtr &odeVariable); - - static bool hasKnownVariables(const AnalyserInternalVariablePtrs &variables); - bool hasKnownVariables(); - - static bool isNonConstantVariable(const AnalyserInternalVariablePtr &variable); - - static bool hasNonConstantVariables(const AnalyserInternalVariablePtrs &variables); - bool hasNonConstantVariables(); - - bool variableOnLhsRhs(const AnalyserInternalVariablePtr &variable, - const AnalyserEquationAstPtr &astChild); - bool variableOnRhs(const AnalyserInternalVariablePtr &variable); - bool variableOnLhsOrRhs(const AnalyserInternalVariablePtr &variable); - - bool check(const AnalyserModelPtr &model, size_t &stateIndex, size_t &computedConstantIndex, size_t &algebraicIndex, bool checkNlaSystems); -}; - AnalyserInternalEquationPtr AnalyserInternalEquation::create(const ComponentPtr &component) { auto res = AnalyserInternalEquationPtr {new AnalyserInternalEquation {}}; @@ -497,139 +376,6 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, return false; } -/** - * @brief The Analyser::AnalyserImpl class. - * - * The private implementation for the Analyser class. - */ -using UnitsMap = std::map; -using UnitsMaps = std::vector; -using UnitsMultipliers = std::vector; - -class Analyser::AnalyserImpl: public Logger::LoggerImpl -{ -public: - class PowerData - { - public: - bool mDimensionlessBase; - bool mExponentValueAvailable = true; - bool mExponentValueChangeable = false; - double mExponentValue; - AnalyserEquationAstPtr mExponentAst; - }; - - Analyser *mAnalyser = nullptr; - - AnalyserModelPtr mModel = AnalyserModel::AnalyserModelImpl::create(); - - AnalyserExternalVariablePtrs mExternalVariables; - - AnalyserInternalVariablePtrs mInternalVariables; - AnalyserInternalEquationPtrs mInternalEquations; - - GeneratorProfilePtr mGeneratorProfile = libcellml::GeneratorProfile::create(); - - std::map mStandardUnits; - std::map mCiCnUnits; - - AnalyserImpl(); - - AnalyserInternalVariablePtr internalVariable(const VariablePtr &variable); - - VariablePtr voiFirstOccurrence(const VariablePtr &variable, - const ComponentPtr &component); - - void analyseNode(const XmlNodePtr &node, AnalyserEquationAstPtr &ast, - const AnalyserEquationAstPtr &astParent, - const ComponentPtr &component, - const AnalyserInternalEquationPtr &equation); - void analyseComponent(const ComponentPtr &component); - void analyseComponentVariables(const ComponentPtr &component); - - void doEquivalentVariables(const VariablePtr &variable, - VariablePtrs &equivalentVariables) const; - VariablePtrs equivalentVariables(const VariablePtr &variable) const; - - void analyseEquationAst(const AnalyserEquationAstPtr &ast); - - void updateUnitsMapWithStandardUnit(const std::string &unitsName, - UnitsMap &unitsMap, - double unitsExponent); - void updateUnitsMap(const ModelPtr &model, const std::string &unitsName, - UnitsMap &unitsMap, bool userUnitsMap = false, - double unitsExponent = 1.0, - double unitsMultiplier = 0.0); - UnitsMap multiplyDivideUnitsMaps(const UnitsMap &firstUnitsMap, - const UnitsMap &secondUnitsMap, - bool multiply); - UnitsMaps multiplyDivideUnitsMaps(const UnitsMaps &firstUnitsMaps, - const UnitsMaps &secondUnitsMaps, - bool multiply = true); - UnitsMaps multiplyDivideUnitsMaps(const UnitsMaps &unitsMaps, - double factor, bool multiply); - double multiplyDivideUnitsMultipliers(double firstUnitsMultiplier, - double secondUnitsMultiplier, - bool multiply); - UnitsMultipliers multiplyDivideUnitsMultipliers(const UnitsMultipliers &firstUnitsMultipliers, - const UnitsMultipliers &secondUnitsMultipliers, - bool multiply = true); - UnitsMultipliers multiplyDivideUnitsMultipliers(double firstUnitsMultiplier, - const UnitsMultipliers &secondUnitsMultipliers, - bool multiply); - UnitsMultipliers powerRootUnitsMultipliers(const UnitsMultipliers &unitsMultipliers, - double factor, bool power); - bool areSameUnitsMaps(const UnitsMaps &firstUnitsMaps, - const UnitsMaps &secondUnitsMaps); - bool isDimensionlessUnitsMaps(const UnitsMaps &unitsMaps); - bool areSameUnitsMultipliers(const UnitsMultipliers &firstUnitsMultipliers, - const UnitsMultipliers &secondUnitsMultipliers); - void updateUnitsMultiplier(const ModelPtr &model, - const std::string &unitsName, - double &newUnitsMultiplier, - double unitsExponent = 1.0, - double unitsMultiplier = 0.0); - std::string componentName(const AnalyserEquationAstPtr &ast); - double powerValue(const AnalyserEquationAstPtr &ast, PowerData &powerData); - std::string expression(const AnalyserEquationAstPtr &ast, - bool includeHierarchy = true); - std::string expressionUnits(const UnitsMaps &unitsMaps, - const UnitsMultipliers &unitsMultipliers = {}); - std::string expressionUnits(const AnalyserEquationAstPtr &ast, - const UnitsMaps &unitsMaps, - const UnitsMaps &userUnitsMaps, - const UnitsMultipliers &unitsMultipliers); - void defaultUnitsMapsAndMultipliers(UnitsMaps &unitsMaps, - UnitsMaps &userUnitsMaps, - UnitsMultipliers &unitsMultipliers); - void analyseEquationUnits(const AnalyserEquationAstPtr &ast, - UnitsMaps &unitsMaps, UnitsMaps &userUnitsMaps, - UnitsMultipliers &unitsMultipliers, - std::string &issueDescription, PowerData &powerData); - - double scalingFactor(const VariablePtr &variable); - - void scaleAst(const AnalyserEquationAstPtr &ast, - const AnalyserEquationAstPtr &astParent, - double scalingFactor); - void scaleEquationAst(const AnalyserEquationAstPtr &ast); - - static bool isExternalVariable(const AnalyserInternalVariablePtr &variable); - - bool isStateRateBased(const AnalyserEquationPtr &equation, - AnalyserEquationPtrs &checkedEquations); - - void addInvalidVariableIssue(const AnalyserInternalVariablePtr &variable, - Issue::ReferenceRule referenceRule); - - void analyseModel(const ModelPtr &model); - - AnalyserExternalVariablePtrs::const_iterator findExternalVariable(const ModelPtr &model, - const std::string &componentName, - const std::string &variableName) const; - AnalyserExternalVariablePtrs::const_iterator findExternalVariable(const AnalyserExternalVariablePtr &externalVariable) const; -}; - Analyser::AnalyserImpl::AnalyserImpl() { // Customise our generator's profile. diff --git a/src/analyser_p.h b/src/analyser_p.h new file mode 100644 index 000000000..138021a95 --- /dev/null +++ b/src/analyser_p.h @@ -0,0 +1,266 @@ +/* +Copyright libCellML Contributors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// #include "libcellml/analyser.h" + +#include "analysermodel_p.h" +#include "internaltypes.h" +#include "issue_p.h" +#include "logger_p.h" +#include "utilities.h" + +namespace libcellml { + +struct AnalyserInternalEquation; +struct AnalyserInternalVariable; + +using AnalyserInternalEquationWeakPtr = std::weak_ptr; +using AnalyserInternalEquationPtr = std::shared_ptr; +using AnalyserInternalVariablePtr = std::shared_ptr; + +using AnalyserInternalEquationWeakPtrs = std::vector; +using AnalyserInternalEquationPtrs = std::vector; +using AnalyserInternalVariablePtrs = std::vector; + +using AnalyserEquationPtrs = std::vector; +using AnalyserVariablePtrs = std::vector; +using AnalyserExternalVariablePtrs = std::vector; + +struct AnalyserInternalVariable +{ + enum struct Type + { + UNKNOWN, + SHOULD_BE_STATE, + INITIALISED, + VARIABLE_OF_INTEGRATION, + STATE, + CONSTANT, + COMPUTED_TRUE_CONSTANT, + COMPUTED_VARIABLE_BASED_CONSTANT, + INITIALISED_ALGEBRAIC, + ALGEBRAIC, + OVERCONSTRAINED + }; + + size_t mIndex = MAX_SIZE_T; + Type mType = Type::UNKNOWN; + bool mIsExternal = false; + + VariablePtr mInitialisingVariable; + VariablePtr mVariable; + VariablePtrs mDependencies; + + static AnalyserInternalVariablePtr create(const VariablePtr &variable); + + void setVariable(const VariablePtr &variable, + bool checkInitialValue = true); + + void makeVoi(); + void makeState(); + void makeConstant(size_t &index); +}; + +struct AnalyserInternalEquation +{ + enum struct Type + { + UNKNOWN, + TRUE_CONSTANT, + VARIABLE_BASED_CONSTANT, + ODE, + NLA, + ALGEBRAIC + }; + + Type mType = Type::UNKNOWN; + + VariablePtrs mDependencies; + + AnalyserEquationAstPtr mAst; + + ComponentPtr mComponent; + + AnalyserInternalVariablePtrs mVariables; + AnalyserInternalVariablePtrs mOdeVariables; + AnalyserInternalVariablePtrs mAllVariables; + AnalyserInternalVariablePtrs mUnknownVariables; + + size_t mNlaSystemIndex = MAX_SIZE_T; + AnalyserInternalEquationWeakPtrs mNlaSiblings; + + bool mComputedTrueConstant = true; + bool mComputedVariableBasedConstant = true; + + static AnalyserInternalEquationPtr create(const ComponentPtr &component); + static AnalyserInternalEquationPtr create(const AnalyserInternalVariablePtr &variable); + + void addVariable(const AnalyserInternalVariablePtr &variable); + void addOdeVariable(const AnalyserInternalVariablePtr &odeVariable); + + static bool isKnownVariable(const AnalyserInternalVariablePtr &variable); + static bool isKnownOdeVariable(const AnalyserInternalVariablePtr &odeVariable); + + static bool hasKnownVariables(const AnalyserInternalVariablePtrs &variables); + bool hasKnownVariables(); + + static bool isNonConstantVariable(const AnalyserInternalVariablePtr &variable); + + static bool hasNonConstantVariables(const AnalyserInternalVariablePtrs &variables); + bool hasNonConstantVariables(); + + bool variableOnLhsRhs(const AnalyserInternalVariablePtr &variable, + const AnalyserEquationAstPtr &astChild); + bool variableOnRhs(const AnalyserInternalVariablePtr &variable); + bool variableOnLhsOrRhs(const AnalyserInternalVariablePtr &variable); + + bool check(const AnalyserModelPtr &model, size_t &stateIndex, size_t &computedConstantIndex, size_t &algebraicIndex, bool checkNlaSystems); +}; + +/** + * @brief The Analyser::AnalyserImpl class. + * + * The private implementation for the Analyser class. + */ +using UnitsMap = std::map; +using UnitsMaps = std::vector; +using UnitsMultipliers = std::vector; + +class Analyser::AnalyserImpl: public Logger::LoggerImpl +{ +public: + class PowerData + { + public: + bool mDimensionlessBase; + bool mExponentValueAvailable = true; + bool mExponentValueChangeable = false; + double mExponentValue; + AnalyserEquationAstPtr mExponentAst; + }; + + Analyser *mAnalyser = nullptr; + + AnalyserModelPtr mModel = AnalyserModel::AnalyserModelImpl::create(); + + AnalyserExternalVariablePtrs mExternalVariables; + + AnalyserInternalVariablePtrs mInternalVariables; + AnalyserInternalEquationPtrs mInternalEquations; + + GeneratorProfilePtr mGeneratorProfile = libcellml::GeneratorProfile::create(); + + std::map mStandardUnits; + std::map mCiCnUnits; + + AnalyserImpl(); + + AnalyserInternalVariablePtr internalVariable(const VariablePtr &variable); + + VariablePtr voiFirstOccurrence(const VariablePtr &variable, + const ComponentPtr &component); + + void analyseNode(const XmlNodePtr &node, AnalyserEquationAstPtr &ast, + const AnalyserEquationAstPtr &astParent, + const ComponentPtr &component, + const AnalyserInternalEquationPtr &equation); + void analyseComponent(const ComponentPtr &component); + void analyseComponentVariables(const ComponentPtr &component); + + void doEquivalentVariables(const VariablePtr &variable, + VariablePtrs &equivalentVariables) const; + VariablePtrs equivalentVariables(const VariablePtr &variable) const; + + void analyseEquationAst(const AnalyserEquationAstPtr &ast); + + void updateUnitsMapWithStandardUnit(const std::string &unitsName, + UnitsMap &unitsMap, + double unitsExponent); + void updateUnitsMap(const ModelPtr &model, const std::string &unitsName, + UnitsMap &unitsMap, bool userUnitsMap = false, + double unitsExponent = 1.0, + double unitsMultiplier = 0.0); + UnitsMap multiplyDivideUnitsMaps(const UnitsMap &firstUnitsMap, + const UnitsMap &secondUnitsMap, + bool multiply); + UnitsMaps multiplyDivideUnitsMaps(const UnitsMaps &firstUnitsMaps, + const UnitsMaps &secondUnitsMaps, + bool multiply = true); + UnitsMaps multiplyDivideUnitsMaps(const UnitsMaps &unitsMaps, + double factor, bool multiply); + double multiplyDivideUnitsMultipliers(double firstUnitsMultiplier, + double secondUnitsMultiplier, + bool multiply); + UnitsMultipliers multiplyDivideUnitsMultipliers(const UnitsMultipliers &firstUnitsMultipliers, + const UnitsMultipliers &secondUnitsMultipliers, + bool multiply = true); + UnitsMultipliers multiplyDivideUnitsMultipliers(double firstUnitsMultiplier, + const UnitsMultipliers &secondUnitsMultipliers, + bool multiply); + UnitsMultipliers powerRootUnitsMultipliers(const UnitsMultipliers &unitsMultipliers, + double factor, bool power); + bool areSameUnitsMaps(const UnitsMaps &firstUnitsMaps, + const UnitsMaps &secondUnitsMaps); + bool isDimensionlessUnitsMaps(const UnitsMaps &unitsMaps); + bool areSameUnitsMultipliers(const UnitsMultipliers &firstUnitsMultipliers, + const UnitsMultipliers &secondUnitsMultipliers); + void updateUnitsMultiplier(const ModelPtr &model, + const std::string &unitsName, + double &newUnitsMultiplier, + double unitsExponent = 1.0, + double unitsMultiplier = 0.0); + std::string componentName(const AnalyserEquationAstPtr &ast); + double powerValue(const AnalyserEquationAstPtr &ast, PowerData &powerData); + std::string expression(const AnalyserEquationAstPtr &ast, + bool includeHierarchy = true); + std::string expressionUnits(const UnitsMaps &unitsMaps, + const UnitsMultipliers &unitsMultipliers = {}); + std::string expressionUnits(const AnalyserEquationAstPtr &ast, + const UnitsMaps &unitsMaps, + const UnitsMaps &userUnitsMaps, + const UnitsMultipliers &unitsMultipliers); + void defaultUnitsMapsAndMultipliers(UnitsMaps &unitsMaps, + UnitsMaps &userUnitsMaps, + UnitsMultipliers &unitsMultipliers); + void analyseEquationUnits(const AnalyserEquationAstPtr &ast, + UnitsMaps &unitsMaps, UnitsMaps &userUnitsMaps, + UnitsMultipliers &unitsMultipliers, + std::string &issueDescription, PowerData &powerData); + + double scalingFactor(const VariablePtr &variable); + + void scaleAst(const AnalyserEquationAstPtr &ast, + const AnalyserEquationAstPtr &astParent, + double scalingFactor); + void scaleEquationAst(const AnalyserEquationAstPtr &ast); + + static bool isExternalVariable(const AnalyserInternalVariablePtr &variable); + + bool isStateRateBased(const AnalyserEquationPtr &equation, + AnalyserEquationPtrs &checkedEquations); + + void addInvalidVariableIssue(const AnalyserInternalVariablePtr &variable, + Issue::ReferenceRule referenceRule); + + void analyseModel(const ModelPtr &model); + + AnalyserExternalVariablePtrs::const_iterator findExternalVariable(const ModelPtr &model, + const std::string &componentName, + const std::string &variableName) const; + AnalyserExternalVariablePtrs::const_iterator findExternalVariable(const AnalyserExternalVariablePtr &externalVariable) const; +}; + +} // namespace libcellml From 8afeb5c99c9e690d8c0827de9d552a3e6a990c42 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 16 Aug 2024 22:50:34 +0200 Subject: [PATCH 33/74] Analyser: simplified things. --- src/analyser.cpp | 94 +++++++++++++++++++++--------------------------- src/analyser_p.h | 14 ++++---- 2 files changed, 48 insertions(+), 60 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index a3a345735..2f1359eee 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -84,9 +84,8 @@ void AnalyserInternalVariable::makeState() } } -void AnalyserInternalVariable::makeConstant(size_t &index) +void AnalyserInternalVariable::makeConstant() { - mIndex = ++index; mType = Type::CONSTANT; } @@ -119,11 +118,11 @@ void AnalyserInternalEquation::addVariable(const AnalyserInternalVariablePtr &va } } -void AnalyserInternalEquation::addOdeVariable(const AnalyserInternalVariablePtr &odeVariable) +void AnalyserInternalEquation::addStateVariable(const AnalyserInternalVariablePtr &stateVariable) { - if (std::find(mOdeVariables.begin(), mOdeVariables.end(), odeVariable) == mOdeVariables.end()) { - mOdeVariables.push_back(odeVariable); - mAllVariables.push_back(odeVariable); + if (std::find(mStateVariables.begin(), mStateVariables.end(), stateVariable) == mStateVariables.end()) { + mStateVariables.push_back(stateVariable); + mAllVariables.push_back(stateVariable); } } @@ -132,9 +131,9 @@ bool AnalyserInternalEquation::isKnownVariable(const AnalyserInternalVariablePtr return variable->mType != AnalyserInternalVariable::Type::UNKNOWN; } -bool AnalyserInternalEquation::isKnownOdeVariable(const AnalyserInternalVariablePtr &odeVariable) +bool AnalyserInternalEquation::isKnownStateVariable(const AnalyserInternalVariablePtr &stateVariable) { - return odeVariable->mIndex != MAX_SIZE_T; + return stateVariable->mIsKnownStateVariable; } bool AnalyserInternalEquation::hasKnownVariables(const AnalyserInternalVariablePtrs &variables) @@ -146,7 +145,7 @@ bool AnalyserInternalEquation::hasKnownVariables(const AnalyserInternalVariableP bool AnalyserInternalEquation::hasKnownVariables() { - return hasKnownVariables(mVariables) || hasKnownVariables(mOdeVariables); + return hasKnownVariables(mVariables) || hasKnownVariables(mStateVariables); } bool AnalyserInternalEquation::isNonConstantVariable(const AnalyserInternalVariablePtr &variable) @@ -156,7 +155,7 @@ bool AnalyserInternalEquation::isNonConstantVariable(const AnalyserInternalVaria // know for sure that it's neither a state variable nor a variable // that is computed using an NLA system. - return variable->mIsExternal + return variable->mIsExternalVariable || ((variable->mType != AnalyserInternalVariable::Type::UNKNOWN) && (variable->mType != AnalyserInternalVariable::Type::INITIALISED) && (variable->mType != AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT) @@ -172,7 +171,7 @@ bool AnalyserInternalEquation::hasNonConstantVariables(const AnalyserInternalVar bool AnalyserInternalEquation::hasNonConstantVariables() { - return hasNonConstantVariables(mVariables) || hasNonConstantVariables(mOdeVariables); + return hasNonConstantVariables(mVariables) || hasNonConstantVariables(mStateVariables); } bool AnalyserInternalEquation::variableOnLhsRhs(const AnalyserInternalVariablePtr &variable, @@ -199,8 +198,7 @@ bool AnalyserInternalEquation::variableOnLhsOrRhs(const AnalyserInternalVariable || variableOnRhs(variable); } -bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, - size_t &stateIndex, size_t &computedConstantIndex, size_t &algebraicIndex, bool checkNlaSystems) +bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, bool checkNlaSystems) { // Nothing to check if the equation has a known type. @@ -208,13 +206,13 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, return false; } - // Determine, from the (new) known (ODE) variables, whether the equation is + // Determine, from the (new) known (state) variables, whether the equation is // used to compute a true constant or a variable-based constant. mComputedTrueConstant = mComputedTrueConstant && !hasKnownVariables(); mComputedVariableBasedConstant = mComputedVariableBasedConstant && !hasNonConstantVariables(); - // Add, as a dependency, the variables used to compute the (new) known (ODE) + // Add, as a dependency, the variables used to compute the (new) known (state) // variables. for (const auto &variable : mVariables) { @@ -223,20 +221,20 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, } } - // Stop tracking (new) known (ODE) variables. + // Stop tracking (new) known (state) variables. mVariables.erase(std::remove_if(mVariables.begin(), mVariables.end(), isKnownVariable), mVariables.end()); - mOdeVariables.erase(std::remove_if(mOdeVariables.begin(), mOdeVariables.end(), isKnownOdeVariable), mOdeVariables.end()); + mStateVariables.erase(std::remove_if(mStateVariables.begin(), mStateVariables.end(), isKnownStateVariable), mStateVariables.end()); - // If there is no (ODE) variable left then it means that the variables in + // If there is no (state) variable left then it means that the variables in // the equation are overconstrained unless one of them was initialised in // which case it will now be considered as an algebraic variable and this // equation as an NLA equation. - auto unknownVariablesOrOdeVariablesLeft = mVariables.size() + mOdeVariables.size(); + auto unknownVariablesOrStateVariablesLeft = mVariables.size() + mStateVariables.size(); AnalyserInternalVariablePtrs initialisedVariables; - if (checkNlaSystems && (unknownVariablesOrOdeVariablesLeft == 0)) { + if (checkNlaSystems && (unknownVariablesOrStateVariablesLeft == 0)) { for (const auto &variable : mAllVariables) { switch (variable->mType) { case AnalyserInternalVariable::Type::INITIALISED: @@ -266,7 +264,7 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, } } - // If there is one (ODE) variable left (on its own on the LHS/RHS of the + // If there is one (state) variable left (on its own on the LHS/RHS of the // equation or in case we check for NLA systems) or some initialised // variables then update its variable (to be the corresponding one in the // component in which the equation is), as well as set its type (if it is @@ -274,9 +272,9 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, // Finally, set the type and order of the equation, should everything have // gone as planned. - auto unknownVariableLeft = (unknownVariablesOrOdeVariablesLeft == 1) ? + auto unknownVariableLeft = (unknownVariablesOrStateVariablesLeft == 1) ? mVariables.empty() ? - mOdeVariables.front() : + mStateVariables.front() : mVariables.front() : nullptr; @@ -284,9 +282,9 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, && (checkNlaSystems || variableOnLhsOrRhs(unknownVariableLeft))) || !initialisedVariables.empty()) { auto variables = mVariables.empty() ? - mOdeVariables.empty() ? + mStateVariables.empty() ? initialisedVariables : - mOdeVariables : + mStateVariables : mVariables; for (const auto &variable : variables) { @@ -313,12 +311,7 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, case AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT: case AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC: case AnalyserInternalVariable::Type::ALGEBRAIC: - variable->mIndex = (variable->mType == AnalyserInternalVariable::Type::STATE) ? - ++stateIndex : - ((variable->mType == AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT) - || (variable->mType == AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT)) ? - ++computedConstantIndex : - ++algebraicIndex; + variable->mIsKnownStateVariable = variable->mType == AnalyserInternalVariable::Type::STATE; mUnknownVariables.push_back(variable); @@ -739,11 +732,11 @@ void Analyser::AnalyserImpl::analyseNode(const XmlNodePtr &node, // something that is not allowed in CellML and will therefore be // reported when we validate the model. - // Have our equation track the (ODE) variable (by ODE variable, we mean + // Have our equation track the (state) variable (by state variable, we mean // a variable that is used in a "diff" element). if (node->parent()->firstChild()->isMathmlElement("diff")) { - equation->addOdeVariable(internalVariable(variable)); + equation->addStateVariable(internalVariable(variable)); } else if (!node->parent()->isMathmlElement("bvar")) { equation->addVariable(internalVariable(variable)); } @@ -2231,7 +2224,7 @@ void Analyser::AnalyserImpl::scaleEquationAst(const AnalyserEquationAstPtr &ast) bool Analyser::AnalyserImpl::isExternalVariable(const AnalyserInternalVariablePtr &variable) { - return variable->mIsExternal; + return variable->mIsExternalVariable; } bool Analyser::AnalyserImpl::isStateRateBased(const AnalyserEquationPtr &equation, @@ -2352,8 +2345,8 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) primaryExternalVariables[internalVariable->mVariable].push_back(variable); - if (!internalVariable->mIsExternal) { - internalVariable->mIsExternal = true; + if (!internalVariable->mIsExternalVariable) { + internalVariable->mIsExternalVariable = true; for (const auto &dependency : externalVariable->dependencies()) { internalVariable->mDependencies.push_back(Analyser::AnalyserImpl::internalVariable(dependency)->mVariable); @@ -2480,7 +2473,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Detmerine whether some variables have been marked as external. auto hasExternalVariables = std::any_of(mInternalVariables.begin(), mInternalVariables.end(), [](const auto &iv) { - return iv->mIsExternal; + return iv->mIsExternalVariable; }); // Loop over our equations, checking which variables, if any, can be @@ -2495,10 +2488,6 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // model invalid) that have been marked as external (rendering the // model valid). - auto stateIndex = MAX_SIZE_T; - auto constantIndex = MAX_SIZE_T; - auto computedConstantIndex = MAX_SIZE_T; - auto algebraicIndex = MAX_SIZE_T; auto loopNumber = 1; bool relevantCheck; auto checkNlaSystems = false; @@ -2507,7 +2496,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) relevantCheck = false; for (const auto &internalEquation : mInternalEquations) { - relevantCheck = internalEquation->check(mModel, stateIndex, computedConstantIndex, algebraicIndex, checkNlaSystems) + relevantCheck = internalEquation->check(mModel, checkNlaSystems) || relevantCheck; } @@ -2522,7 +2511,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // marked as external and we go through the two loops one more time. for (const auto &internalVariable : mInternalVariables) { - if (internalVariable->mIsExternal + if (internalVariable->mIsExternalVariable && (internalVariable->mType == AnalyserInternalVariable::Type::UNKNOWN)) { internalVariable->mType = AnalyserInternalVariable::Type::INITIALISED; } @@ -2552,7 +2541,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) case AnalyserInternalVariable::Type::INITIALISED: // The variable is (still) initialised so it has to be a constant. - internalVariable->makeConstant(constantIndex); + internalVariable->makeConstant(); break; case AnalyserInternalVariable::Type::OVERCONSTRAINED: @@ -2606,7 +2595,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) if (internalEquation->mType == AnalyserInternalEquation::Type::NLA) { for (const auto &unknownVariable : internalEquation->mUnknownVariables) { - if (unknownVariable->mIsExternal + if (unknownVariable->mIsExternalVariable && (std::find(addedExternalVariables.begin(), addedExternalVariables.end(), unknownVariable) == addedExternalVariables.end())) { addedExternalVariables.push_back(unknownVariable); addedInternalEquations.push_back(AnalyserInternalEquation::create(unknownVariable)); @@ -2754,7 +2743,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // have been marked as external return std::any_of(ie->mUnknownVariables.begin(), ie->mUnknownVariables.end(), [](const auto &uv) { - return !uv->mIsExternal; + return !uv->mIsExternalVariable; }); } @@ -2814,7 +2803,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) auto externalEquation = true; for (const auto &unknownVariable : internalEquation->mUnknownVariables) { - if (!unknownVariable->mIsExternal) { + if (!unknownVariable->mIsExternalVariable) { externalEquation = false; break; @@ -2866,19 +2855,18 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) std::map aiv2avMappings; std::map v2avMappings; + auto stateIndex = MAX_SIZE_T; + auto constantIndex = MAX_SIZE_T; + auto computedConstantIndex = MAX_SIZE_T; + auto algebraicIndex = MAX_SIZE_T; auto externalIndex = MAX_SIZE_T; - stateIndex = MAX_SIZE_T; - constantIndex = MAX_SIZE_T; - computedConstantIndex = MAX_SIZE_T; - algebraicIndex = MAX_SIZE_T; - for (const auto &internalVariable : mInternalVariables) { // Determine the type of the variable. AnalyserVariable::Type type; - if (internalVariable->mIsExternal) { + if (internalVariable->mIsExternalVariable) { type = AnalyserVariable::Type::EXTERNAL; } else { switch (internalVariable->mType) { diff --git a/src/analyser_p.h b/src/analyser_p.h index 138021a95..f79606e06 100644 --- a/src/analyser_p.h +++ b/src/analyser_p.h @@ -56,9 +56,9 @@ struct AnalyserInternalVariable OVERCONSTRAINED }; - size_t mIndex = MAX_SIZE_T; Type mType = Type::UNKNOWN; - bool mIsExternal = false; + bool mIsKnownStateVariable = false; + bool mIsExternalVariable = false; VariablePtr mInitialisingVariable; VariablePtr mVariable; @@ -71,7 +71,7 @@ struct AnalyserInternalVariable void makeVoi(); void makeState(); - void makeConstant(size_t &index); + void makeConstant(); }; struct AnalyserInternalEquation @@ -95,7 +95,7 @@ struct AnalyserInternalEquation ComponentPtr mComponent; AnalyserInternalVariablePtrs mVariables; - AnalyserInternalVariablePtrs mOdeVariables; + AnalyserInternalVariablePtrs mStateVariables; AnalyserInternalVariablePtrs mAllVariables; AnalyserInternalVariablePtrs mUnknownVariables; @@ -109,10 +109,10 @@ struct AnalyserInternalEquation static AnalyserInternalEquationPtr create(const AnalyserInternalVariablePtr &variable); void addVariable(const AnalyserInternalVariablePtr &variable); - void addOdeVariable(const AnalyserInternalVariablePtr &odeVariable); + void addStateVariable(const AnalyserInternalVariablePtr &stateVariable); static bool isKnownVariable(const AnalyserInternalVariablePtr &variable); - static bool isKnownOdeVariable(const AnalyserInternalVariablePtr &odeVariable); + static bool isKnownStateVariable(const AnalyserInternalVariablePtr &stateVariable); static bool hasKnownVariables(const AnalyserInternalVariablePtrs &variables); bool hasKnownVariables(); @@ -127,7 +127,7 @@ struct AnalyserInternalEquation bool variableOnRhs(const AnalyserInternalVariablePtr &variable); bool variableOnLhsOrRhs(const AnalyserInternalVariablePtr &variable); - bool check(const AnalyserModelPtr &model, size_t &stateIndex, size_t &computedConstantIndex, size_t &algebraicIndex, bool checkNlaSystems); + bool check(const AnalyserModelPtr &model, bool checkNlaSystems); }; /** From 40d3fb497c6543757fcbddaa0c0c6cb7203492a1 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Sat, 17 Aug 2024 11:14:53 +0200 Subject: [PATCH 34/74] Generator: make sure that constants are initialised when they are needed to initialise a state. --- src/generator.cpp | 48 +++++++++++-------- .../model.c | 2 +- .../model.py | 2 +- .../model.c | 4 +- .../model.py | 4 +- .../model.c | 2 +- .../model.py | 2 +- 7 files changed, 37 insertions(+), 27 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index 9f62dfb95..b9551a249 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1813,11 +1813,26 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st auto implementationInitialiseVariablesMethodString = mProfile->implementationInitialiseVariablesMethodString(modelHasOdes()); if (!implementationInitialiseVariablesMethodString.empty()) { - // Initialise our states. + // Initialise our states (after, if needed, initialising the constant on which it depends). std::string methodBody; + auto constants = mModel->constants(); for (const auto &state : mModel->states()) { + auto initialisingVariable = state->initialisingVariable(); + auto initialValue = initialisingVariable->initialValue(); + + if (!isCellMLReal(initialValue)) { + auto constant = std::find_if(constants.begin(), constants.end(), + [=](const AnalyserVariablePtr &av) -> bool { return av->variable()->name() == initialValue; }); + + if (constant != constants.end()) { + methodBody += generateInitialisationCode(*constant); + + constants.erase(constant); + } + } + methodBody += generateInitialisationCode(state); } @@ -1830,29 +1845,24 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st } } - // Initialise our constants and our algebraic variables that have an initial value. Also use an initial guess of - // zero for algebraic variables computed using an NLA system. + // Initialise our constants. + + for (const auto &constant : constants) { + methodBody += generateInitialisationCode(constant); + } + + // Initialise our algebraic variables that have an initial value. Also use an initial guess of zero for + // algebraic variables computed using an NLA system. // Note: a variable which is the only unknown in an equation, but which is not on its own on either the LHS or // RHS of that equation (e.g., x = y+z with x and y known and z unknown) is (currently) to be computed // using an NLA system for which we need an initial guess. We use an initial guess of zero, which is fine // since such an NLA system has only one solution. - for (const auto &variable : variables(mModel)) { - switch (variable->type()) { - case AnalyserVariable::Type::CONSTANT: - methodBody += generateInitialisationCode(variable); - - break; - case AnalyserVariable::Type::ALGEBRAIC: - if (variable->initialisingVariable() != nullptr) { - methodBody += generateInitialisationCode(variable); - } else if (variable->equation(0)->type() == AnalyserEquation::Type::NLA) { - methodBody += generateZeroInitialisationCode(variable); - } - - break; - default: // Other types we don't care about. - break; + for (const auto &algebraic : mModel->algebraic()) { + if (algebraic->initialisingVariable() != nullptr) { + methodBody += generateInitialisationCode(algebraic); + } else if (algebraic->equation(0)->type() == AnalyserEquation::Type::NLA) { + methodBody += generateZeroInitialisationCode(algebraic); } } diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index a146b4d20..67ec8957e 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -80,8 +80,8 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { - states[0] = constants[0]; constants[0] = 123.0; + states[0] = constants[0]; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 032002fb9..8ce57554e 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -46,8 +46,8 @@ def create_algebraic_array(): def initialise_variables(voi, states, rates, constants, algebraic): - states[0] = constants[0] constants[0] = 123.0 + states[0] = constants[0] def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index 363343cd2..e860b309e 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -82,10 +82,10 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { - states[0] = constants[0]; - states[1] = 0.001*constants[1]; constants[0] = 123.0; + states[0] = constants[0]; constants[1] = 789.0; + states[1] = 0.001*constants[1]; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 7e03b6de1..b58354e4b 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -48,10 +48,10 @@ def create_algebraic_array(): def initialise_variables(voi, states, rates, constants, algebraic): - states[0] = constants[0] - states[1] = 0.001*constants[1] constants[0] = 123.0 + states[0] = constants[0] constants[1] = 789.0 + states[1] = 0.001*constants[1] def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index e4500b462..4539a6618 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -80,8 +80,8 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { - states[0] = constants[0]; constants[0] = 7.0; + states[0] = constants[0]; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 539c2776c..092c15be2 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -46,8 +46,8 @@ def create_algebraic_array(): def initialise_variables(voi, states, rates, constants, algebraic): - states[0] = constants[0] constants[0] = 7.0 + states[0] = constants[0] def compute_computed_constants(constants, computed_constants): From b32d169a7d08b41959e00927e23c1a31f27ea1d0 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 19 Aug 2024 11:13:44 +0200 Subject: [PATCH 35/74] Generator: renamed the "external" array to "externals". Oversight on my part! --- src/generatorprofile.cpp | 4 +-- src/generatorprofilesha1values.h | 4 +-- .../bindings/python/test_generator_profile.py | 2 +- tests/generator/generatorprofile.cpp | 2 +- .../model.external.c | 4 +-- .../model.external.py | 4 +-- .../model.external.c | 2 +- .../model.external.py | 2 +- .../model.three.externals.c | 6 ++--- .../model.three.externals.py | 6 ++--- .../cell_geometry_model/model.external.c | 6 ++--- .../cell_geometry_model/model.external.py | 6 ++--- .../model.algebraic.c | 6 ++--- .../model.algebraic.py | 6 ++--- .../model.computed.constant.c | 8 +++--- .../model.computed.constant.py | 8 +++--- .../model.constant.c | 6 ++--- .../model.constant.py | 6 ++--- .../model.dependent.algebraic.c | 12 ++++----- .../model.dependent.algebraic.py | 12 ++++----- .../model.dependent.computed.constant.c | 20 +++++++------- .../model.dependent.computed.constant.py | 20 +++++++------- .../model.dependent.constant.c | 14 +++++----- .../model.dependent.constant.py | 14 +++++----- .../model.dependent.state.c | 24 ++++++++--------- .../model.dependent.state.py | 24 ++++++++--------- .../model.external.c | 26 +++++++++---------- .../model.external.py | 26 +++++++++---------- .../model.state.c | 8 +++--- .../model.state.py | 8 +++--- .../model.c | 4 +-- .../model.py | 4 +-- 32 files changed, 152 insertions(+), 152 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 8de812817..08d9b9a82 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -288,7 +288,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mConstantsArrayString = "constants"; mComputedConstantsArrayString = "computedConstants"; mAlgebraicArrayString = "algebraic"; - mExternalArrayString = "external"; + mExternalArrayString = "externals"; mExternalVariableMethodTypeDefinitionFamString = "typedef double (* ExternalVariable)(double *variables, size_t index);\n"; mExternalVariableMethodTypeDefinitionFdmString = "typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index);\n"; @@ -729,7 +729,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mConstantsArrayString = "constants"; mComputedConstantsArrayString = "computed_constants"; mAlgebraicArrayString = "algebraic"; - mExternalArrayString = "external"; + mExternalArrayString = "externals"; mExternalVariableMethodTypeDefinitionFamString = ""; mExternalVariableMethodTypeDefinitionFdmString = ""; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index dacc0b264..6d03642ad 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "323f0e5824d5c794c28f34dda5e7410efc836e62"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "3f6672212636b5179b23b9664cead525f54f665f"; +static const char C_GENERATOR_PROFILE_SHA1[] = "ad23abd7fbd49d6b76113c14b0d2ec4c7df09d41"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "cced8fe15a79248bc3902c9f45637b053243fc98"; } // namespace libcellml diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index c030ba9c8..d4d8703e5 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -1667,7 +1667,7 @@ def test_external_array_string(self): g = GeneratorProfile() - self.assertEqual('external', g.externalArrayString()) + self.assertEqual('externals', g.externalArrayString()) g.setExternalArrayString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalArrayString()) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 155af5a07..62bdb259f 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -340,7 +340,7 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("constants", generatorProfile->constantsArrayString()); EXPECT_EQ("computedConstants", generatorProfile->computedConstantsArrayString()); EXPECT_EQ("algebraic", generatorProfile->algebraicArrayString()); - EXPECT_EQ("external", generatorProfile->externalArrayString()); + EXPECT_EQ("externals", generatorProfile->externalArrayString()); EXPECT_EQ("typedef double (* ExternalVariable)(double *variables, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(false)); EXPECT_EQ("typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(true)); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 5cea89727..670484b6a 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -86,6 +86,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[0] = externalVariable(variables, 0); - algebraic[0] = external[0]; + externals[0] = externalVariable(variables, 0); + algebraic[0] = externals[0]; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 8ce48759d..08357f1ee 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -52,5 +52,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - external[0] = external_variable(variables, 0) - algebraic[0] = external[0] + externals[0] = external_variable(variables, 0) + algebraic[0] = externals[0] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index 2d502bbe6..ba2a7e905 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -91,5 +91,5 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[0] = externalVariable(variables, 0); + externals[0] = externalVariable(variables, 0); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 67217abb1..1253e4dad 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -56,4 +56,4 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - external[0] = external_variable(variables, 0) + externals[0] = external_variable(variables, 0) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index 620fc5523..25af29ada 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -87,7 +87,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[0] = externalVariable(variables, 0); - external[1] = externalVariable(variables, 1); - external[2] = externalVariable(variables, 2); + externals[0] = externalVariable(variables, 0); + externals[1] = externalVariable(variables, 1); + externals[2] = externalVariable(variables, 2); } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index 1b2b68c5f..fbc56b715 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -53,6 +53,6 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - external[0] = external_variable(variables, 0) - external[1] = external_variable(variables, 1) - external[2] = external_variable(variables, 2) + externals[0] = external_variable(variables, 0) + externals[1] = external_variable(variables, 1) + externals[2] = external_variable(variables, 2) diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index c4c33c7c0..a57c6692c 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -88,8 +88,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[0] = externalVariable(variables, 0); - external[1] = externalVariable(variables, 1); - algebraic[0] = 1000.0*3.14*external[1]*external[1]*external[0]; + externals[0] = externalVariable(variables, 0); + externals[1] = externalVariable(variables, 1); + algebraic[0] = 1000.0*3.14*externals[1]*externals[1]*externals[0]; algebraic[1] = 0.02*algebraic[0]; } diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 8f9555d5c..e220d2e73 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -54,7 +54,7 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - external[0] = external_variable(variables, 0) - external[1] = external_variable(variables, 1) - algebraic[0] = 1000.0*3.14*external[1]*external[1]*external[0] + externals[0] = external_variable(variables, 0) + externals[1] = external_variable(variables, 1) + algebraic[0] = 1000.0*3.14*externals[1]*externals[1]*externals[0] algebraic[1] = 0.02*algebraic[0] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 3ca0c5371..cdeae6291 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -135,11 +135,11 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, variables, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-external[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; + rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[4] = 4.0*exp(states[0]/18.0); rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2]; @@ -153,7 +153,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, variables, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index bbc403eae..efe508ad1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -104,11 +104,11 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, variables, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-external[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0] + rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0] algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[4] = 4.0*exp(states[0]/18.0) rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2] @@ -121,7 +121,7 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, variables, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 9de4002c1..2e6435a24 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -135,8 +135,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[2]*(states[0]-external[0]); + externals[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[2]*(states[0]-externals[0]); algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; @@ -153,8 +153,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[2]*(states[0]-external[0]); + externals[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[2]*(states[0]-externals[0]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index a9fd749a9..a1324eb79 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -104,8 +104,8 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[2]*(states[0]-external[0]) + externals[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[2]*(states[0]-externals[0]) algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] @@ -121,8 +121,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[2]*(states[0]-external[0]) + externals[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[2]*(states[0]-externals[0]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 83398ea28..6d271f592 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -135,11 +135,11 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - external[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, variables, 0); algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[0]; + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0]; algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; @@ -162,5 +162,5 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(states[0]/80.0); - external[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, variables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index e5b794335..b3951a5dd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -104,11 +104,11 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, variables, 0) algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[0] + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0] algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] @@ -130,4 +130,4 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(states[0]/80.0) - external[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 63f4f0572..f10c3958b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -135,12 +135,12 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[1] = externalVariable(voi, states, rates, variables, 1); - external[0] = externalVariable(voi, states, rates, variables, 0); + externals[1] = externalVariable(voi, states, rates, variables, 1); + externals[0] = externalVariable(voi, states, rates, variables, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-external[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; + rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[4] = 4.0*exp(states[0]/18.0); rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2]; @@ -148,13 +148,13 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1]; algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = algebraic[7]*(1.0-states[3])-external[1]*states[3]; + rates[3] = algebraic[7]*(1.0-states[3])-externals[1]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[1] = externalVariable(voi, states, rates, variables, 1); - external[0] = externalVariable(voi, states, rates, variables, 0); + externals[1] = externalVariable(voi, states, rates, variables, 1); + externals[0] = externalVariable(voi, states, rates, variables, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index e78d84cca..716cafe93 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -104,12 +104,12 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[1] = external_variable(voi, states, rates, variables, 1) - external[0] = external_variable(voi, states, rates, variables, 0) + externals[1] = external_variable(voi, states, rates, variables, 1) + externals[0] = external_variable(voi, states, rates, variables, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-external[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0] + rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0] algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[4] = 4.0*exp(states[0]/18.0) rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2] @@ -117,12 +117,12 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1] algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = algebraic[7]*(1.0-states[3])-external[1]*states[3] + rates[3] = algebraic[7]*(1.0-states[3])-externals[1]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[1] = external_variable(voi, states, rates, variables, 1) - external[0] = external_variable(voi, states, rates, variables, 0) + externals[1] = external_variable(voi, states, rates, variables, 1) + externals[0] = external_variable(voi, states, rates, variables, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 1763e10c0..08b086b89 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -132,12 +132,12 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - external[1] = externalVariable(voi, states, rates, variables, 1); - external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[4] = external[0]-10.613; + externals[1] = externalVariable(voi, states, rates, variables, 1); + externals[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[4] = externals[0]-10.613; algebraic[1] = constants[1]*(states[0]-algebraic[4]); - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[1]); - algebraic[5] = external[0]-115.0; + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]); + algebraic[5] = externals[0]-115.0; algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); @@ -153,17 +153,17 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[1] = externalVariable(voi, states, rates, variables, 1); - external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[4] = external[0]-10.613; + externals[1] = externalVariable(voi, states, rates, variables, 1); + externals[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[4] = externals[0]-10.613; algebraic[1] = constants[1]*(states[0]-algebraic[4]); - algebraic[5] = external[0]-115.0; + algebraic[5] = externals[0]-115.0; algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]); algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[7] = 4.0*exp(states[0]/18.0); algebraic[8] = 0.07*exp(states[0]/20.0); algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[1]); + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]); algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[11] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 2ff358773..0a961a48b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -102,12 +102,12 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external[1] = external_variable(voi, states, rates, variables, 1) - external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[4] = external[0]-10.613 + externals[1] = external_variable(voi, states, rates, variables, 1) + externals[0] = external_variable(voi, states, rates, variables, 0) + algebraic[4] = externals[0]-10.613 algebraic[1] = constants[1]*(states[0]-algebraic[4]) - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[1]) - algebraic[5] = external[0]-115.0 + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]) + algebraic[5] = externals[0]-115.0 algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) @@ -122,16 +122,16 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[1] = external_variable(voi, states, rates, variables, 1) - external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[4] = external[0]-10.613 + externals[1] = external_variable(voi, states, rates, variables, 1) + externals[0] = external_variable(voi, states, rates, variables, 0) + algebraic[4] = externals[0]-10.613 algebraic[1] = constants[1]*(states[0]-algebraic[4]) - algebraic[5] = external[0]-115.0 + algebraic[5] = externals[0]-115.0 algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]) algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[7] = 4.0*exp(states[0]/18.0) algebraic[8] = 0.07*exp(states[0]/20.0) algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external[1]) + algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]) algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[11] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index bf11e3c35..45f29d072 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -134,12 +134,12 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - external[1] = externalVariable(voi, states, rates, variables, 1); - external[0] = externalVariable(voi, states, rates, variables, 0); + externals[1] = externalVariable(voi, states, rates, variables, 1); + externals[0] = externalVariable(voi, states, rates, variables, 0); algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[3] = external[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[0]; + algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0]; algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; @@ -154,8 +154,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = constants[1]*(states[0]-computedConstants[0]); - external[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[3] = external[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + externals[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); algebraic[6] = 0.07*exp(states[0]/20.0); @@ -163,5 +163,5 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(states[0]/80.0); - external[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, variables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 523a74854..7fb9fbb6f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -103,12 +103,12 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external[1] = external_variable(voi, states, rates, variables, 1) - external[0] = external_variable(voi, states, rates, variables, 0) + externals[1] = external_variable(voi, states, rates, variables, 1) + externals[0] = external_variable(voi, states, rates, variables, 0) algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[3] = external[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/external[0] + algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0] algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] @@ -122,8 +122,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[1] = constants[1]*(states[0]-computed_constants[0]) - external[1] = external_variable(voi, states, rates, variables, 1) - algebraic[3] = external[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + externals[1] = external_variable(voi, states, rates, variables, 1) + algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) algebraic[6] = 0.07*exp(states[0]/20.0) @@ -131,4 +131,4 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(states[0]/80.0) - external[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index e9bb071d9..f5f5a253f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -133,23 +133,23 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[6] = 0.07*exp(external[0]/20.0); - algebraic[7] = 1.0/(exp((external[0]+30.0)/10.0)+1.0); + externals[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[6] = 0.07*exp(externals[0]/20.0); + algebraic[7] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0); rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0]; - algebraic[8] = 0.01*(external[0]+10.0)/(exp((external[0]+10.0)/10.0)-1.0); - algebraic[9] = 0.125*exp(external[0]/80.0); + algebraic[8] = 0.01*(externals[0]+10.0)/(exp((externals[0]+10.0)/10.0)-1.0); + algebraic[9] = 0.125*exp(externals[0]/80.0); rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[2]*(external[0]-computedConstants[0]); - external[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[3] = constants[3]*pow(external[1], 3.0)*states[0]*(external[0]-computedConstants[1]); - algebraic[4] = 0.1*(external[0]+25.0)/(exp((external[0]+25.0)/10.0)-1.0); - algebraic[5] = 4.0*exp(external[0]/18.0); - algebraic[2] = constants[4]*pow(states[1], 4.0)*(external[0]-computedConstants[2]); + externals[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[2]*(externals[0]-computedConstants[0]); + externals[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[3] = constants[3]*pow(externals[1], 3.0)*states[0]*(externals[0]-computedConstants[1]); + algebraic[4] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0); + algebraic[5] = 4.0*exp(externals[0]/18.0); + algebraic[2] = constants[4]*pow(states[1], 4.0)*(externals[0]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index f4e175bb2..cb704989d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -102,21 +102,21 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[6] = 0.07*exp(external[0]/20.0) - algebraic[7] = 1.0/(exp((external[0]+30.0)/10.0)+1.0) + externals[0] = external_variable(voi, states, rates, variables, 0) + algebraic[6] = 0.07*exp(externals[0]/20.0) + algebraic[7] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0) rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0] - algebraic[8] = 0.01*(external[0]+10.0)/(exp((external[0]+10.0)/10.0)-1.0) - algebraic[9] = 0.125*exp(external[0]/80.0) + algebraic[8] = 0.01*(externals[0]+10.0)/(exp((externals[0]+10.0)/10.0)-1.0) + algebraic[9] = 0.125*exp(externals[0]/80.0) rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[2]*(external[0]-computed_constants[0]) - external[1] = external_variable(voi, states, rates, variables, 1) - algebraic[3] = constants[3]*pow(external[1], 3.0)*states[0]*(external[0]-computed_constants[1]) - algebraic[4] = 0.1*(external[0]+25.0)/(exp((external[0]+25.0)/10.0)-1.0) - algebraic[5] = 4.0*exp(external[0]/18.0) - algebraic[2] = constants[4]*pow(states[1], 4.0)*(external[0]-computed_constants[2]) + externals[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[2]*(externals[0]-computed_constants[0]) + externals[1] = external_variable(voi, states, rates, variables, 1) + algebraic[3] = constants[3]*pow(externals[1], 3.0)*states[0]*(externals[0]-computed_constants[1]) + algebraic[4] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0) + algebraic[5] = 4.0*exp(externals[0]/18.0) + algebraic[2] = constants[4]*pow(states[1], 4.0)*(externals[0]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index d23067e7b..4dd384571 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -134,24 +134,24 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[3] = 0.1*(external[0]+25.0)/(exp((external[0]+25.0)/10.0)-1.0); - algebraic[4] = 4.0*exp(external[0]/18.0); + externals[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[3] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0); + algebraic[4] = 4.0*exp(externals[0]/18.0); rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1]; - algebraic[5] = 0.07*exp(external[0]/20.0); - algebraic[6] = 1.0/(exp((external[0]+30.0)/10.0)+1.0); + algebraic[5] = 0.07*exp(externals[0]/20.0); + algebraic[6] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0); rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0]; - external[2] = externalVariable(voi, states, rates, variables, 2); - algebraic[7] = 0.125*exp(external[0]/80.0); - rates[2] = external[2]*(1.0-states[2])-algebraic[7]*states[2]; + externals[2] = externalVariable(voi, states, rates, variables, 2); + algebraic[7] = 0.125*exp(externals[0]/80.0); + rates[2] = externals[2]*(1.0-states[2])-algebraic[7]*states[2]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[1] = constants[2]*(external[0]-computedConstants[0]); - external[2] = externalVariable(voi, states, rates, variables, 2); - external[1] = externalVariable(voi, states, rates, variables, 1); - algebraic[2] = constants[4]*pow(states[2], 4.0)*(external[0]-computedConstants[2]); + externals[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[1] = constants[2]*(externals[0]-computedConstants[0]); + externals[2] = externalVariable(voi, states, rates, variables, 2); + externals[1] = externalVariable(voi, states, rates, variables, 1); + algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[0]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 7e7ce5804..fd8453ffc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -103,22 +103,22 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[3] = 0.1*(external[0]+25.0)/(exp((external[0]+25.0)/10.0)-1.0) - algebraic[4] = 4.0*exp(external[0]/18.0) + externals[0] = external_variable(voi, states, rates, variables, 0) + algebraic[3] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0) + algebraic[4] = 4.0*exp(externals[0]/18.0) rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1] - algebraic[5] = 0.07*exp(external[0]/20.0) - algebraic[6] = 1.0/(exp((external[0]+30.0)/10.0)+1.0) + algebraic[5] = 0.07*exp(externals[0]/20.0) + algebraic[6] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0) rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0] - external[2] = external_variable(voi, states, rates, variables, 2) - algebraic[7] = 0.125*exp(external[0]/80.0) - rates[2] = external[2]*(1.0-states[2])-algebraic[7]*states[2] + externals[2] = external_variable(voi, states, rates, variables, 2) + algebraic[7] = 0.125*exp(externals[0]/80.0) + rates[2] = externals[2]*(1.0-states[2])-algebraic[7]*states[2] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[1] = constants[2]*(external[0]-computed_constants[0]) - external[2] = external_variable(voi, states, rates, variables, 2) - external[1] = external_variable(voi, states, rates, variables, 1) - algebraic[2] = constants[4]*pow(states[2], 4.0)*(external[0]-computed_constants[2]) + externals[0] = external_variable(voi, states, rates, variables, 0) + algebraic[1] = constants[2]*(externals[0]-computed_constants[0]) + externals[2] = external_variable(voi, states, rates, variables, 2) + externals[1] = external_variable(voi, states, rates, variables, 1) + algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[0]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index fb03fdd45..205334d7b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -137,8 +137,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraic[1] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); - external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[3] = constants[3]*pow(external[0], 3.0)*states[1]*(states[0]-computedConstants[1]); + externals[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; algebraic[6] = 0.07*exp(states[0]/20.0); algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); @@ -151,8 +151,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - external[0] = externalVariable(voi, states, rates, variables, 0); - algebraic[3] = constants[3]*pow(external[0], 3.0)*states[1]*(states[0]-computedConstants[1]); + externals[0] = externalVariable(voi, states, rates, variables, 0); + algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); algebraic[6] = 0.07*exp(states[0]/20.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 19e213325..b97e82403 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -106,8 +106,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic[1] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) - external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[3] = constants[3]*pow(external[0], 3.0)*states[1]*(states[0]-computed_constants[1]) + externals[0] = external_variable(voi, states, rates, variables, 0) + algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] algebraic[6] = 0.07*exp(states[0]/20.0) algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) @@ -119,8 +119,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - external[0] = external_variable(voi, states, rates, variables, 0) - algebraic[3] = constants[3]*pow(external[0], 3.0)*states[1]*(states[0]-computed_constants[1]) + externals[0] = external_variable(voi, states, rates, variables, 0) + algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) algebraic[6] = 0.07*exp(states[0]/20.0) diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 2eecb84e5..8b023706c 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -102,6 +102,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - external[0] = externalVariable(variables, 0); - algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+external[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]); + externals[0] = externalVariable(variables, 0); + algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+externals[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]); } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 1d02c1f0b..4a8e5e195 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -67,5 +67,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - external[0] = external_variable(variables, 0) - algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+external[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) + externals[0] = external_variable(variables, 0) + algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+externals[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) From 8cba9cdf5c4fa56a861123ed35623b664433996d Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 19 Aug 2024 11:45:04 +0200 Subject: [PATCH 36/74] Generator: "initialise" computed constants in initialiseVariables(). This effectively reverts commit b1b75362. Indeed, some computed constants are initialised using an equation (e.g., x = 3 rather than x with an initial value of 3). So, there is no need to compute those computed constants many times (using computeComputedConstants()). Instead, it's much better to compute them in initialiseVariables(). Not to mention that we might have "computedConstants[1] = 1.0;" and then "computedConstants[0] = computedConstants[1];" so if we were to compute both of them in computeComputedConstants(), we would need to compute "computedConstants[1] = 1.0;" before computing "computedConstants[0] = computedConstants[1];", which would make things slightly more complicated to generate. --- src/generator.cpp | 17 +++---------- tests/resources/coverage/generator/model.c | 24 +++++++++---------- .../generator/model.implementation.out | 24 +++++++++---------- .../generator/model.modified.profile.c | 24 +++++++++---------- .../generator/model.modified.profile.py | 24 +++++++++---------- tests/resources/coverage/generator/model.out | 24 +++++++++---------- tests/resources/coverage/generator/model.py | 24 +++++++++---------- .../algebraic_eqn_computed_var_on_rhs/model.c | 2 +- .../model.py | 3 +-- .../algebraic_eqn_constant_on_rhs/model.c | 2 +- .../algebraic_eqn_constant_on_rhs/model.py | 4 ++-- .../algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 3 ++- .../model.c | 2 +- .../model.py | 3 ++- .../algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs/model.py | 3 ++- .../model.c | 2 +- .../model.py | 3 ++- .../model.c | 6 ++--- .../model.external.c | 6 ++--- .../model.external.py | 8 +++---- .../model.py | 7 +++--- .../algebraic_unknown_var_on_rhs/model.c | 2 +- .../algebraic_unknown_var_on_rhs/model.py | 3 +-- .../generator/ode_computed_var_on_rhs/model.c | 2 +- .../ode_computed_var_on_rhs/model.py | 3 ++- .../model.c | 2 +- .../model.py | 3 ++- .../generator/sine_model_imports/model.c | 8 +++---- .../generator/sine_model_imports/model.py | 7 +++--- 31 files changed, 122 insertions(+), 127 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index b9551a249..dd26dbb1a 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1866,16 +1866,12 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st } } - // Initialise our (initialised) true constants. - // Note: this means that we don't initialise (computed) constants that are initialised using a true constant - // through an equation (e.g., x = 3 rather than x with an initial value of 3), hence we test the number - // of constants in the equation. + // Initialise our true constants. auto equations = mModel->equations(); for (const auto &equation : equations) { - if ((equation->constantCount() == 1) - && (equation->type() == AnalyserEquation::Type::TRUE_CONSTANT)) { + if (equation->type() == AnalyserEquation::Type::TRUE_CONSTANT) { methodBody += generateEquationCode(equation, remainingEquations); } } @@ -1889,17 +1885,10 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st void Generator::GeneratorImpl::addImplementationComputeComputedConstantsMethodCode(std::vector &remainingEquations) { if (!mProfile->implementationComputeComputedConstantsMethodString().empty()) { - // Initialise all our computed constants. - // Note: this means (computed) constants that are initialised using an equation that relies on constant - // variables (e.g., x = a + b, with a and b being constants), as well as (computed) constants that are - // initialised using a true constant through an equation (e.g., x = 3 rather than x with an initial value - // of 3). - std::string methodBody; for (const auto &equation : mModel->equations()) { - if ((equation->type() == AnalyserEquation::Type::TRUE_CONSTANT) - || (equation->type() == AnalyserEquation::Type::VARIABLE_BASED_CONSTANT)) { + if (equation->type() == AnalyserEquation::Type::VARIABLE_BASED_CONSTANT) { methodBody += generateEquationCode(equation, remainingEquations); } } diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 72b66e639..8b2dc7755 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -417,6 +417,18 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[6] = 7.0; algebraic[0] = 1.0; algebraic[1] = 2.0; + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -598,17 +610,7 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; computedConstants[175] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; computedConstants[176] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; computedConstants[181] = constants[0]; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; computedConstants[188] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); computedConstants[189] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); computedConstants[190] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); @@ -619,8 +621,6 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[195] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); computedConstants[196] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); computedConstants[197] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 9879365ae..2198bce7b 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -180,6 +180,18 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[6] = 7.0; algebraic[0] = 1.0; algebraic[1] = 2.0; + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -361,17 +373,7 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[174] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:NAN; computedConstants[175] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:constants[6]; computedConstants[176] = 123.0+((gt(constants[0], constants[1]))?constants[0]:NAN); - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; computedConstants[181] = constants[0]; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; computedConstants[188] = and(constants[0], constants[1])+((gt(constants[2], constants[3]))?constants[1]:NAN)+constants[4]+and(constants[5], constants[6]); computedConstants[189] = and(constants[0], constants[1])-(((gt(constants[2], constants[3]))?constants[1]:NAN)-(constants[4]-((gt(constants[2], constants[3]))?constants[1]:NAN)))-and(constants[5], constants[6]); computedConstants[190] = and(constants[0], constants[1])*((gt(constants[2], constants[3]))?constants[1]:NAN)*constants[4]*((gt(constants[2], constants[3]))?constants[1]:NAN)*and(constants[5], constants[6]); @@ -382,8 +384,6 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[195] = pow(and(constants[0], constants[1]), pow((gt(constants[2], constants[3]))?constants[1]:NAN, pow(pow(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), and(constants[0], constants[1])))); computedConstants[196] = pow(pow(pow(and(constants[0], constants[1]), 1.0/pow((gt(constants[2], constants[3]))?constants[1]:NAN, 1.0/constants[4])), 1.0/((gt(constants[2], constants[3]))?constants[1]:NAN)), 1.0/and(constants[0], constants[1])); computedConstants[197] = -and(constants[0], constants[1])+-((gt(constants[2], constants[3]))?constants[1]:NAN); - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 4d98fe81b..710c1d897 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -417,6 +417,18 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[6] = 7.0; algebraic[0] = 1.0; algebraic[1] = 2.0; + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -598,17 +610,7 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; computedConstants[175] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; computedConstants[176] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; computedConstants[181] = constants[0]; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; computedConstants[188] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); computedConstants[189] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); computedConstants[190] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); @@ -619,8 +621,6 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[195] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); computedConstants[196] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); computedConstants[197] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index eb7f0514f..ba16c980b 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -394,6 +394,18 @@ def initialise_variables(voi, states, rates, constants, algebraic): constants[6] = 7.0 algebraic[0] = 1.0 algebraic[1] = 2.0 + computed_constants[177] = 123.0 + computed_constants[178] = 123.456789 + computed_constants[179] = 123.0e99 + computed_constants[180] = 123.456789e99 + computed_constants[182] = 1.0 + computed_constants[183] = 0.0 + computed_constants[184] = 2.71828182845905 + computed_constants[185] = 3.14159265358979 + computed_constants[186] = inf + computed_constants[187] = nan + computed_constants[198] = 1.0 + computed_constants[199] = 3.0 def compute_computed_constants(constants, computed_constants): @@ -574,17 +586,7 @@ def compute_computed_constants(constants, computed_constants): computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan computed_constants[175] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] computed_constants[176] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) - computed_constants[177] = 123.0 - computed_constants[178] = 123.456789 - computed_constants[179] = 123.0e99 - computed_constants[180] = 123.456789e99 computed_constants[181] = constants[0] - computed_constants[182] = 1.0 - computed_constants[183] = 0.0 - computed_constants[184] = 2.71828182845905 - computed_constants[185] = 3.14159265358979 - computed_constants[186] = inf - computed_constants[187] = nan computed_constants[188] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) computed_constants[189] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) computed_constants[190] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) @@ -595,8 +597,6 @@ def compute_computed_constants(constants, computed_constants): computed_constants[195] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) computed_constants[196] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) computed_constants[197] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) - computed_constants[198] = 1.0 - computed_constants[199] = 3.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index d57486a8d..6ced968c7 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -128,6 +128,18 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[6] = 7.0; algebraic[0] = 1.0; algebraic[1] = 2.0; + computedConstants[177] = 123.0; + computedConstants[178] = 123.456789; + computedConstants[179] = 123.0e99; + computedConstants[180] = 123.456789e99; + computedConstants[182] = 1.0; + computedConstants[183] = 0.0; + computedConstants[184] = 2.71828182845905; + computedConstants[185] = 3.14159265358979; + computedConstants[186] = INFINITY; + computedConstants[187] = NAN; + computedConstants[198] = 1.0; + computedConstants[199] = 3.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -309,17 +321,7 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[174] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], NAN))); computedConstants[175] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], constants[6]))); computedConstants[176] = 123.0+piecewise(constants[0] > constants[1], constants[0], NAN); - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; computedConstants[181] = constants[0]; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; computedConstants[188] = (constants[0] && constants[1])+piecewise(constants[2] > constants[3], constants[1], NAN)+constants[4]+(constants[5] && constants[6]); computedConstants[189] = (constants[0] && constants[1])-(piecewise(constants[2] > constants[3], constants[1], NAN)-(constants[4]-piecewise(constants[2] > constants[3], constants[1], NAN)))-(constants[5] && constants[6]); computedConstants[190] = (constants[0] && constants[1])*piecewise(constants[2] > constants[3], constants[1], NAN)*constants[4]*piecewise(constants[2] > constants[3], constants[1], NAN)*(constants[5] && constants[6]); @@ -330,8 +332,6 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[195] = (constants[0] && constants[1])^^(piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[4]^^piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[0] && constants[1]))); computedConstants[196] = (constants[0] && constants[1])^^(1.0/(piecewise(constants[2] > constants[3], constants[1], NAN)^^(1.0/constants[4])))^^(1.0/piecewise(constants[2] > constants[3], constants[1], NAN))^^(1.0/(constants[0] && constants[1])); computedConstants[197] = -(constants[0] && constants[1])+-piecewise(constants[2] > constants[3], constants[1], NAN); - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 8f5da46a7..948be5f36 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -394,6 +394,18 @@ def initialise_variables(voi, states, rates, constants, algebraic): constants[6] = 7.0 algebraic[0] = 1.0 algebraic[1] = 2.0 + computed_constants[177] = 123.0 + computed_constants[178] = 123.456789 + computed_constants[179] = 123.0e99 + computed_constants[180] = 123.456789e99 + computed_constants[182] = 1.0 + computed_constants[183] = 0.0 + computed_constants[184] = 2.71828182845905 + computed_constants[185] = 3.14159265358979 + computed_constants[186] = inf + computed_constants[187] = nan + computed_constants[198] = 1.0 + computed_constants[199] = 3.0 def compute_computed_constants(constants, computed_constants): @@ -574,17 +586,7 @@ def compute_computed_constants(constants, computed_constants): computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan computed_constants[175] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] computed_constants[176] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) - computed_constants[177] = 123.0 - computed_constants[178] = 123.456789 - computed_constants[179] = 123.0e99 - computed_constants[180] = 123.456789e99 computed_constants[181] = constants[0] - computed_constants[182] = 1.0 - computed_constants[183] = 0.0 - computed_constants[184] = 2.71828182845905 - computed_constants[185] = 3.14159265358979 - computed_constants[186] = inf - computed_constants[187] = nan computed_constants[188] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) computed_constants[189] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) computed_constants[190] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) @@ -595,8 +597,6 @@ def compute_computed_constants(constants, computed_constants): computed_constants[195] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) computed_constants[196] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) computed_constants[197] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) - computed_constants[198] = 1.0 - computed_constants[199] = 3.0 def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index 77864fe75..a3c00b62d 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -63,12 +63,12 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic) { + computedConstants[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { computedConstants[0] = computedConstants[1]; - computedConstants[1] = 1.0; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index 7478720bd..e16ebcdbb 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -36,12 +36,11 @@ def create_algebraic_array(): def initialise_variables(constants, algebraic): - pass + computed_constants[1] = 1.0 def compute_computed_constants(constants, computed_constants): computed_constants[0] = computed_constants[1] - computed_constants[1] = 1.0 def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index 44c462e66..f4791714a 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -62,11 +62,11 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic) { + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 1.0; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index ec6d22f69..af04c489b 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -35,11 +35,11 @@ def create_algebraic_array(): def initialise_variables(constants, algebraic): - pass + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 1.0 + pass def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 014cbdc35..d5fb727cd 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -82,11 +82,11 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index c82c2e861..32d4574de 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -48,10 +48,11 @@ def create_algebraic_array(): def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 1.0 + pass def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index c87a0e1ce..c081714e4 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -82,11 +82,11 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 427ddf5b9..a6c1827be 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -48,10 +48,11 @@ def create_algebraic_array(): def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 1.0 + pass def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 92edb5255..ce09a9984 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -82,11 +82,11 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index a2c96535a..25d0f4e4d 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -48,10 +48,11 @@ def create_algebraic_array(): def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 1.0 + pass def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 7e852f4e1..fd550fc19 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -82,11 +82,11 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index a16626a8f..62519628b 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -48,10 +48,11 @@ def create_algebraic_array(): def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 1.0 + pass def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index f197a0f5d..105a0833d 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -94,13 +94,13 @@ void findRoot0(double *variables) void initialiseVariables(double *constants, double *algebraic) { algebraic[0] = 1.0; + computedConstants[0] = 3.0; + computedConstants[1] = 5.0; + computedConstants[2] = 7.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 3.0; - computedConstants[1] = 5.0; - computedConstants[2] = 7.0; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index ba2a7e905..41a543f1d 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -80,13 +80,13 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic) { + computedConstants[0] = 3.0; + computedConstants[1] = 5.0; + computedConstants[2] = 7.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 3.0; - computedConstants[1] = 5.0; - computedConstants[2] = 7.0; } void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 1253e4dad..86cfcf351 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -46,14 +46,14 @@ def create_externals_array(): def initialise_variables(constants, algebraic): - pass - - -def compute_computed_constants(constants, computed_constants): computed_constants[0] = 3.0 computed_constants[1] = 5.0 computed_constants[2] = 7.0 +def compute_computed_constants(constants, computed_constants): + pass + + def compute_variables(constants, computed_constants, algebraic, external_variable): externals[0] = external_variable(variables, 0) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index d0b04d108..df36f9d08 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -60,13 +60,14 @@ def find_root_0(variables): def initialise_variables(constants, algebraic): algebraic[0] = 1.0 - - -def compute_computed_constants(constants, computed_constants): computed_constants[0] = 3.0 computed_constants[1] = 5.0 computed_constants[2] = 7.0 +def compute_computed_constants(constants, computed_constants): + pass + + def compute_variables(constants, computed_constants, algebraic): find_root_0(variables) diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index dc329bd29..48c8e8533 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -63,11 +63,11 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *algebraic) { + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 1.0; computedConstants[1] = computedConstants[0]; } diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 56ec81b7e..34185c7ef 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -36,11 +36,10 @@ def create_algebraic_array(): def initialise_variables(constants, algebraic): - pass + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 1.0 computed_constants[1] = computed_constants[0] diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index e353013d0..7e82c1532 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -81,11 +81,11 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index d5856eb24..2ac23adae 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -47,10 +47,11 @@ def create_algebraic_array(): def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 1.0 + pass def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 77dc8431b..6c40a92a7 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -81,11 +81,11 @@ void deleteArray(double *array) void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) { states[0] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 1.0; } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 1de612165..6d8e7ec5d 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -47,10 +47,11 @@ def create_algebraic_array(): def initialise_variables(voi, states, rates, constants, algebraic): states[0] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 1.0 + pass def compute_rates(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 167815f03..3d3b671d0 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -92,10 +92,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons states[0] = constants[0]; constants[0] = 0.0; constants[1] = 0.75; -} - -void computeComputedConstants(double *constants, double *computedConstants) -{ computedConstants[0] = 2.0/3.14159265358979; computedConstants[1] = 2.0*3.14159265358979; computedConstants[2] = 3.14159265358979/2.0; @@ -103,6 +99,10 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[4] = 3.0*3.14159265358979/2.0; } +void computeComputedConstants(double *constants, double *computedConstants) +{ +} + void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { rates[0] = cos(voi); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 272f8268b..0204c1bc9 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -62,9 +62,6 @@ def initialise_variables(voi, states, rates, constants, algebraic): states[0] = constants[0] constants[0] = 0.0 constants[1] = 0.75 - - -def compute_computed_constants(constants, computed_constants): computed_constants[0] = 2.0/3.14159265358979 computed_constants[1] = 2.0*3.14159265358979 computed_constants[2] = 3.14159265358979/2.0 @@ -72,6 +69,10 @@ def compute_computed_constants(constants, computed_constants): computed_constants[4] = 3.0*3.14159265358979/2.0 +def compute_computed_constants(constants, computed_constants): + pass + + def compute_rates(voi, states, rates, constants, computed_constants, algebraic): rates[0] = cos(voi) From 65e1d18c39ce0a7ebfa7e4648156644c0afa3515 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 19 Aug 2024 14:46:15 +0200 Subject: [PATCH 37/74] Generator: initialise things in initialiseVariables() in the order of its parameters. --- src/generator.cpp | 21 ++++++++++--------- tests/resources/coverage/generator/model.c | 4 ++-- .../generator/model.implementation.out | 4 ++-- .../generator/model.modified.profile.c | 4 ++-- .../generator/model.modified.profile.py | 4 ++-- tests/resources/coverage/generator/model.out | 4 ++-- tests/resources/coverage/generator/model.py | 4 ++-- .../model.c | 2 +- .../model.py | 2 +- 9 files changed, 25 insertions(+), 24 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index dd26dbb1a..f11c2e000 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1851,6 +1851,17 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st methodBody += generateInitialisationCode(constant); } + // Initialise our computed constants that are initialised using an equation (e.g., x = 3 rather than x with an + // initial value of 3). + + auto equations = mModel->equations(); + + for (const auto &equation : equations) { + if (equation->type() == AnalyserEquation::Type::TRUE_CONSTANT) { + methodBody += generateEquationCode(equation, remainingEquations); + } + } + // Initialise our algebraic variables that have an initial value. Also use an initial guess of zero for // algebraic variables computed using an NLA system. // Note: a variable which is the only unknown in an equation, but which is not on its own on either the LHS or @@ -1866,16 +1877,6 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st } } - // Initialise our true constants. - - auto equations = mModel->equations(); - - for (const auto &equation : equations) { - if (equation->type() == AnalyserEquation::Type::TRUE_CONSTANT) { - methodBody += generateEquationCode(equation, remainingEquations); - } - } - mCode += newLineIfNeeded() + replace(implementationInitialiseVariablesMethodString, "[CODE]", generateMethodBodyCode(methodBody)); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 8b2dc7755..897a70503 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -415,8 +415,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[4] = 5.0; constants[5] = 6.0; constants[6] = 7.0; - algebraic[0] = 1.0; - algebraic[1] = 2.0; computedConstants[177] = 123.0; computedConstants[178] = 123.456789; computedConstants[179] = 123.0e99; @@ -429,6 +427,8 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons computedConstants[187] = NAN; computedConstants[198] = 1.0; computedConstants[199] = 3.0; + algebraic[0] = 1.0; + algebraic[1] = 2.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 2198bce7b..a224e4f34 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -178,8 +178,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[4] = 5.0; constants[5] = 6.0; constants[6] = 7.0; - algebraic[0] = 1.0; - algebraic[1] = 2.0; computedConstants[177] = 123.0; computedConstants[178] = 123.456789; computedConstants[179] = 123.0e99; @@ -192,6 +190,8 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons computedConstants[187] = NAN; computedConstants[198] = 1.0; computedConstants[199] = 3.0; + algebraic[0] = 1.0; + algebraic[1] = 2.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 710c1d897..bc61303a2 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -415,8 +415,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[4] = 5.0; constants[5] = 6.0; constants[6] = 7.0; - algebraic[0] = 1.0; - algebraic[1] = 2.0; computedConstants[177] = 123.0; computedConstants[178] = 123.456789; computedConstants[179] = 123.0e99; @@ -429,6 +427,8 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons computedConstants[187] = NAN; computedConstants[198] = 1.0; computedConstants[199] = 3.0; + algebraic[0] = 1.0; + algebraic[1] = 2.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index ba16c980b..ab520ec75 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -392,8 +392,6 @@ def initialise_variables(voi, states, rates, constants, algebraic): constants[4] = 5.0 constants[5] = 6.0 constants[6] = 7.0 - algebraic[0] = 1.0 - algebraic[1] = 2.0 computed_constants[177] = 123.0 computed_constants[178] = 123.456789 computed_constants[179] = 123.0e99 @@ -406,6 +404,8 @@ def initialise_variables(voi, states, rates, constants, algebraic): computed_constants[187] = nan computed_constants[198] = 1.0 computed_constants[199] = 3.0 + algebraic[0] = 1.0 + algebraic[1] = 2.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index 6ced968c7..b30c5e3a6 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -126,8 +126,6 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons constants[4] = 5.0; constants[5] = 6.0; constants[6] = 7.0; - algebraic[0] = 1.0; - algebraic[1] = 2.0; computedConstants[177] = 123.0; computedConstants[178] = 123.456789; computedConstants[179] = 123.0e99; @@ -140,6 +138,8 @@ void initialiseVariables(double voi, double *states, double *rates, double *cons computedConstants[187] = NAN; computedConstants[198] = 1.0; computedConstants[199] = 3.0; + algebraic[0] = 1.0; + algebraic[1] = 2.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 948be5f36..ed21a14b9 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -392,8 +392,6 @@ def initialise_variables(voi, states, rates, constants, algebraic): constants[4] = 5.0 constants[5] = 6.0 constants[6] = 7.0 - algebraic[0] = 1.0 - algebraic[1] = 2.0 computed_constants[177] = 123.0 computed_constants[178] = 123.456789 computed_constants[179] = 123.0e99 @@ -406,6 +404,8 @@ def initialise_variables(voi, states, rates, constants, algebraic): computed_constants[187] = nan computed_constants[198] = 1.0 computed_constants[199] = 3.0 + algebraic[0] = 1.0 + algebraic[1] = 2.0 def compute_computed_constants(constants, computed_constants): diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 105a0833d..fb406af3a 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -93,10 +93,10 @@ void findRoot0(double *variables) void initialiseVariables(double *constants, double *algebraic) { - algebraic[0] = 1.0; computedConstants[0] = 3.0; computedConstants[1] = 5.0; computedConstants[2] = 7.0; + algebraic[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index df36f9d08..5022e2f82 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -59,10 +59,10 @@ def find_root_0(variables): def initialise_variables(constants, algebraic): - algebraic[0] = 1.0 computed_constants[0] = 3.0 computed_constants[1] = 5.0 computed_constants[2] = 7.0 + algebraic[0] = 1.0 def compute_computed_constants(constants, computed_constants): From 327225a9e1cf7668d929e2a5088a6578d2e41358 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 19 Aug 2024 14:59:26 +0200 Subject: [PATCH 38/74] GeneratorProfile: pass the computedConstants array to initialiseVariables(). --- src/generatorprofile.cpp | 12 ++++++------ src/generatorprofilesha1values.h | 4 ++-- tests/bindings/python/test_generator_profile.py | 8 ++++---- tests/generator/generatorprofile.cpp | 8 ++++---- tests/resources/coverage/generator/model.c | 2 +- tests/resources/coverage/generator/model.h | 2 +- .../coverage/generator/model.implementation.out | 2 +- .../resources/coverage/generator/model.interface.out | 2 +- .../coverage/generator/model.modified.profile.c | 2 +- .../coverage/generator/model.modified.profile.h | 2 +- .../coverage/generator/model.modified.profile.py | 2 +- tests/resources/coverage/generator/model.out | 2 +- tests/resources/coverage/generator/model.py | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.h | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.py | 2 +- .../generator/algebraic_eqn_const_var_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_const_var_on_rhs/model.h | 2 +- .../algebraic_eqn_const_var_on_rhs/model.py | 2 +- .../generator/algebraic_eqn_constant_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_constant_on_rhs/model.h | 2 +- .../generator/algebraic_eqn_constant_on_rhs/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs/model.h | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.h | 2 +- .../algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.three.externals.c | 2 +- .../model.three.externals.h | 2 +- .../model.three.externals.py | 2 +- .../model.not.ordered.c | 2 +- .../model.not.ordered.h | 2 +- .../model.not.ordered.py | 2 +- .../model.ordered.c | 2 +- .../model.ordered.h | 2 +- .../model.ordered.py | 2 +- .../generator/algebraic_unknown_var_on_rhs/model.c | 2 +- .../generator/algebraic_unknown_var_on_rhs/model.h | 2 +- .../generator/algebraic_unknown_var_on_rhs/model.py | 2 +- .../resources/generator/cell_geometry_model/model.c | 2 +- .../generator/cell_geometry_model/model.external.c | 2 +- .../generator/cell_geometry_model/model.external.h | 2 +- .../generator/cell_geometry_model/model.external.py | 2 +- .../resources/generator/cell_geometry_model/model.h | 2 +- .../resources/generator/cell_geometry_model/model.py | 2 +- .../cellml_mappings_and_encapsulations/model.c | 2 +- .../cellml_mappings_and_encapsulations/model.h | 2 +- .../cellml_mappings_and_encapsulations/model.py | 2 +- .../resources/generator/cellml_slc_example/model.py | 2 +- .../cellml_state_initialised_using_variable/model.c | 2 +- .../cellml_state_initialised_using_variable/model.h | 2 +- .../cellml_state_initialised_using_variable/model.py | 2 +- .../generator/cellml_unit_scaling_constant/model.c | 2 +- .../generator/cellml_unit_scaling_constant/model.h | 2 +- .../generator/cellml_unit_scaling_constant/model.py | 2 +- .../generator/cellml_unit_scaling_rate/model.c | 2 +- .../generator/cellml_unit_scaling_rate/model.h | 2 +- .../generator/cellml_unit_scaling_rate/model.py | 2 +- .../generator/cellml_unit_scaling_state/model.c | 2 +- .../generator/cellml_unit_scaling_state/model.h | 2 +- .../generator/cellml_unit_scaling_state/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.c | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.h | 2 +- .../cellml_unit_scaling_voi_direct/model.py | 2 +- .../cellml_unit_scaling_voi_indirect/model.c | 2 +- .../cellml_unit_scaling_voi_indirect/model.h | 2 +- .../cellml_unit_scaling_voi_indirect/model.py | 2 +- .../resources/generator/dae_cellml_1_1_model/model.c | 2 +- .../resources/generator/dae_cellml_1_1_model/model.h | 2 +- .../generator/dae_cellml_1_1_model/model.py | 2 +- tests/resources/generator/dependent_eqns/model.c | 2 +- tests/resources/generator/dependent_eqns/model.h | 2 +- tests/resources/generator/dependent_eqns/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.algebraic.c | 2 +- .../model.algebraic.h | 2 +- .../model.algebraic.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.c | 2 +- .../model.computed.constant.c | 2 +- .../model.computed.constant.h | 2 +- .../model.computed.constant.py | 2 +- .../model.constant.c | 2 +- .../model.constant.h | 2 +- .../model.constant.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.h | 2 +- .../model.dae.py | 2 +- .../model.dependent.algebraic.c | 2 +- .../model.dependent.algebraic.h | 2 +- .../model.dependent.algebraic.py | 2 +- .../model.dependent.computed.constant.c | 2 +- .../model.dependent.computed.constant.h | 2 +- .../model.dependent.computed.constant.py | 2 +- .../model.dependent.constant.c | 2 +- .../model.dependent.constant.h | 2 +- .../model.dependent.constant.py | 2 +- .../model.dependent.state.c | 2 +- .../model.dependent.state.h | 2 +- .../model.dependent.state.py | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.py | 2 +- .../model.state.c | 2 +- .../model.state.h | 2 +- .../model.state.py | 2 +- tests/resources/generator/noble_model_1962/model.c | 2 +- tests/resources/generator/noble_model_1962/model.h | 2 +- tests/resources/generator/noble_model_1962/model.py | 2 +- .../generator/ode_computed_var_on_rhs/model.c | 2 +- .../generator/ode_computed_var_on_rhs/model.h | 2 +- .../generator/ode_computed_var_on_rhs/model.py | 2 +- .../ode_computed_var_on_rhs_one_component/model.c | 2 +- .../ode_computed_var_on_rhs_one_component/model.h | 2 +- .../ode_computed_var_on_rhs_one_component/model.py | 2 +- .../resources/generator/ode_const_var_on_rhs/model.c | 2 +- .../resources/generator/ode_const_var_on_rhs/model.h | 2 +- .../generator/ode_const_var_on_rhs/model.py | 2 +- .../ode_const_var_on_rhs_one_component/model.c | 2 +- .../ode_const_var_on_rhs_one_component/model.h | 2 +- .../ode_const_var_on_rhs_one_component/model.py | 2 +- .../resources/generator/ode_constant_on_rhs/model.c | 2 +- .../resources/generator/ode_constant_on_rhs/model.h | 2 +- .../resources/generator/ode_constant_on_rhs/model.py | 2 +- .../ode_constant_on_rhs_one_component/model.c | 2 +- .../ode_constant_on_rhs_one_component/model.h | 2 +- .../ode_constant_on_rhs_one_component/model.py | 2 +- .../generator/ode_multiple_dependent_odes/model.c | 2 +- .../generator/ode_multiple_dependent_odes/model.h | 2 +- .../generator/ode_multiple_dependent_odes/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../ode_multiple_odes_with_same_name/model.c | 2 +- .../ode_multiple_odes_with_same_name/model.h | 2 +- .../ode_multiple_odes_with_same_name/model.py | 2 +- .../generator/ode_unknown_var_on_rhs/model.c | 2 +- .../generator/ode_unknown_var_on_rhs/model.h | 2 +- .../generator/ode_unknown_var_on_rhs/model.py | 2 +- .../generator/robertson_model_1966/model.dae.c | 2 +- .../generator/robertson_model_1966/model.dae.h | 2 +- .../generator/robertson_model_1966/model.dae.py | 2 +- .../generator/robertson_model_1966/model.ode.c | 2 +- .../generator/robertson_model_1966/model.ode.h | 2 +- .../generator/robertson_model_1966/model.ode.py | 2 +- tests/resources/generator/sine_model_imports/model.c | 2 +- tests/resources/generator/sine_model_imports/model.h | 2 +- .../resources/generator/sine_model_imports/model.py | 2 +- .../unknown_variable_as_external_variable/model.c | 2 +- .../unknown_variable_as_external_variable/model.h | 2 +- .../unknown_variable_as_external_variable/model.py | 2 +- .../variable_initialised_using_a_constant/model.c | 2 +- .../variable_initialised_using_a_constant/model.h | 2 +- .../variable_initialised_using_a_constant/model.py | 2 +- 185 files changed, 197 insertions(+), 197 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 08d9b9a82..0179deb7f 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -409,14 +409,14 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " free(array);\n" "}\n"; - mInterfaceInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *algebraic);\n"; - mImplementationInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *algebraic)\n" + mInterfaceInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *computedConstants, double *algebraic);\n"; + mImplementationInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n"; - mInterfaceInitialiseVariablesMethodFdmString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic);\n"; - mImplementationInitialiseVariablesMethodFdmString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic)\n" + mInterfaceInitialiseVariablesMethodFdmString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n"; + mImplementationInitialiseVariablesMethodFdmString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n"; @@ -802,12 +802,12 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceInitialiseVariablesMethodFamString = ""; mImplementationInitialiseVariablesMethodFamString = "\n" - "def initialise_variables(constants, algebraic):\n" + "def initialise_variables(constants, computed_constants, algebraic):\n" "[CODE]"; mInterfaceInitialiseVariablesMethodFdmString = ""; mImplementationInitialiseVariablesMethodFdmString = "\n" - "def initialise_variables(voi, states, rates, constants, algebraic):\n" + "def initialise_variables(voi, states, rates, constants, computed_constants, algebraic):\n" "[CODE]"; mInterfaceComputeComputedConstantsMethodString = ""; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 6d03642ad..a208a5986 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "ad23abd7fbd49d6b76113c14b0d2ec4c7df09d41"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "cced8fe15a79248bc3902c9f45637b053243fc98"; +static const char C_GENERATOR_PROFILE_SHA1[] = "22b2ada38f83adad3e70dd776ef9d72c7c1a966f"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "405499117ed4245fbee40c3d18303ee748e3a1a2"; } // namespace libcellml diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index d4d8703e5..fad40298b 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -838,12 +838,12 @@ def test_implementation_initialise_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void initialiseVariables(double *constants, double *algebraic)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(False)) g.setImplementationInitialiseVariablesMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(False)) - self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(True)) g.setImplementationInitialiseVariablesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(True)) @@ -1117,12 +1117,12 @@ def test_interface_initialise_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void initialiseVariables(double *constants, double *algebraic);\n', + self.assertEqual('void initialiseVariables(double *constants, double *computedConstants, double *algebraic);\n', g.interfaceInitialiseVariablesMethodString(False)) g.setInterfaceInitialiseVariablesMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(False)) - self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic);\n', + self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n', g.interfaceInitialiseVariablesMethodString(True)) g.setInterfaceInitialiseVariablesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(True)) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 62bdb259f..ab038a263 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -486,17 +486,17 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationDeleteArrayMethodString()); - EXPECT_EQ("void initialiseVariables(double *constants, double *algebraic);\n", + EXPECT_EQ("void initialiseVariables(double *constants, double *computedConstants, double *algebraic);\n", generatorProfile->interfaceInitialiseVariablesMethodString(false)); - EXPECT_EQ("void initialiseVariables(double *constants, double *algebraic)\n" + EXPECT_EQ("void initialiseVariables(double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationInitialiseVariablesMethodString(false)); - EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic);\n", + EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n", generatorProfile->interfaceInitialiseVariablesMethodString(true)); - EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic)\n" + EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n", diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 897a70503..8b52167d6 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -405,7 +405,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 5d9a4cbdc..c22174b70 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index a224e4f34..6a38edeaf 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -168,7 +168,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index 5fa121175..a444951dc 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -11,7 +11,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index bc61303a2..5653c51ae 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -405,7 +405,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 99e4b49f1..6cc99016d 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index ab520ec75..89ec8121c 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -383,7 +383,7 @@ def find_root_0(voi, states, rates, variables): algebraic[1] = u[1] -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 constants[0] = 1.0 constants[1] = 2.0 diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index b30c5e3a6..514bac2e1 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -116,7 +116,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index ed21a14b9..a211b39e5 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -383,7 +383,7 @@ def find_root_0(voi, states, rates, variables): algebraic[1] = u[1] -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 constants[0] = 1.0 constants[1] = 2.0 diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index a3c00b62d..e2e640d06 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { computedConstants[1] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 670484b6a..70e5a39b8 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -76,7 +76,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index 96a917b0a..949208875 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 08357f1ee..244859d72 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -43,7 +43,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index 1f34a6c51..c8faff2f6 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index e16ebcdbb..ecf5e3ada 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -35,7 +35,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): computed_constants[1] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index 844244bab..9677a8153 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { constants[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index 1f34a6c51..c8faff2f6 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index 1f58e7d6f..16a15e2d4 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -35,7 +35,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index f4791714a..38d6117d3 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -60,7 +60,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index 214a248c0..c317e5693 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index af04c489b..93ffb01d8 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -34,7 +34,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index d5fb727cd..9c2f823f6 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index fe567bfd6..c50e027fc 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 32d4574de..3f7bc9517 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index c081714e4..8c72b66ab 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index d2fac6dd0..7672524c3 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index a6c1827be..598b58e85 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index ce09a9984..3131bc653 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index 57b67a4db..981651ccd 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 25d0f4e4d..c655ba461 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index fd550fc19..02014ef23 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index 2cb538a2f..46e07c2dd 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 62519628b..013484cee 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index fb406af3a..bd2b6cf18 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -91,7 +91,7 @@ void findRoot0(double *variables) algebraic[0] = u[0]; } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = 3.0; computedConstants[1] = 5.0; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index 41a543f1d..43fe422a9 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = 3.0; computedConstants[1] = 5.0; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index 96a917b0a..949208875 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 86cfcf351..c5a93e2ac 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -45,7 +45,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): computed_constants[0] = 3.0 computed_constants[1] = 5.0 computed_constants[2] = 7.0 diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index 1f34a6c51..c8faff2f6 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 5022e2f82..199da80a2 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -58,7 +58,7 @@ def find_root_0(variables): algebraic[0] = u[0] -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): computed_constants[0] = 3.0 computed_constants[1] = 5.0 computed_constants[2] = 7.0 diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index 0dbe3d9a8..f2362c836 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -98,7 +98,7 @@ void findRoot0(double *variables) algebraic[2] = u[2]; } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { algebraic[0] = 1.0; algebraic[1] = 1.0; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index 20d7d3dd9..9fdff0e0c 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 2e9fe582c..08b001bda 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -65,7 +65,7 @@ def find_root_0(variables): algebraic[2] = u[2] -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): algebraic[0] = 1.0 algebraic[1] = 1.0 algebraic[2] = 1.0 diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c index 25af29ada..bc5780016 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h index 63c13e639..33b790575 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py index fbc56b715..7d519d04b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py @@ -44,7 +44,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index dec7a4953..eb6901bc6 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -97,7 +97,7 @@ void findRoot0(double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { constants[0] = 3.0; constants[1] = 5.0; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index 20d7d3dd9..9fdff0e0c 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index a38ce9d1e..31584bc6c 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -64,7 +64,7 @@ def find_root_0(variables): algebraic[1] = u[1] -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): constants[0] = 3.0 constants[1] = 5.0 algebraic[1] = 1.0 diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index 1cfcef840..f44603229 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -97,7 +97,7 @@ void findRoot0(double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { constants[0] = 3.0; constants[1] = 5.0; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index 20d7d3dd9..9fdff0e0c 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index a7badc953..7cc2478a0 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -64,7 +64,7 @@ def find_root_0(variables): algebraic[1] = u[1] -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): constants[0] = 3.0 constants[1] = 5.0 algebraic[0] = 1.0 diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index 48c8e8533..75949bb58 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index 214a248c0..c317e5693 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 34185c7ef..a9b08bd06 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -35,7 +35,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): computed_constants[0] = 1.0 diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index 5e019e3e4..9d3f10451 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -63,7 +63,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { constants[0] = 0.01; constants[1] = 0.0011; diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index a57c6692c..1b946f417 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 0fc34b150..28c04e714 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index e220d2e73..463fb5960 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -45,7 +45,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index 01b945a3a..bcf58d80e 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index a8a99bf87..a427cc5ff 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -37,7 +37,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): constants[0] = 0.01 constants[1] = 0.0011 diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 17813b55b..dfeedb00f 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index 43685c5ba..d668e10ba 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 75604f927..cde62f28c 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -47,7 +47,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 0.0 diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index f7fd19efa..848d4a722 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -43,7 +43,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): constants[0] = 1.1 constants[1] = 21262500.0 constants[2] = 150.0 diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index 67ec8957e..ac395dd3b 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { constants[0] = 123.0; states[0] = constants[0]; diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index ab266738e..125d289e6 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 8ce57554e..f2e9eb525 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): constants[0] = 123.0 states[0] = constants[0] diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 096f85064..3d259be88 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -62,7 +62,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { constants[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index d7919125e..1e51b94dd 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -27,6 +27,6 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index b6ea3f00d..16717c06e 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -36,7 +36,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): constants[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index d714d284d..604d08c5f 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index ab266738e..125d289e6 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 8b002e808..45678f11d 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index b9aa6f1bc..ac805fa9e 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index ab266738e..125d289e6 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index a419ddf98..d88e7699c 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index f98746f5c..5e7d345e2 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 123.0; states[1] = 0.001*789.0; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index e56356d45..ca1a66c12 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index fd82e9c5f..4bf6281a0 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 123.0 states[1] = 0.001*789.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index e860b309e..d7e12ef11 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { constants[0] = 123.0; states[0] = constants[0]; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 67cbb918d..7f150918f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index b58354e4b..648e23013 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -47,7 +47,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): constants[0] = 123.0 states[0] = constants[0] constants[1] = 789.0 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index d545a0557..630608791 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 3.0; states[1] = 5.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index e29840b4e..a415fa4ae 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index 2d7f9ee98..fa2831f8f 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 3.0 states[1] = 5.0 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index 1a7319f7d..4d5382792 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 3.0; states[1] = 7.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index c5193145b..68f3a5146 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index 9bc446530..824dc3e08 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 3.0 states[1] = 7.0 states[2] = 11.0 diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index b4a2873d6..fbf6e9c03 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -146,7 +146,7 @@ void findRoot1(double voi, double *states, double *rates, double *variables) algebraic[4] = u[0]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index d677f483c..4aeac109d 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index b5f846ce9..55f5a6153 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -100,7 +100,7 @@ def find_root_1(voi, states, rates, variables): algebraic[4] = u[0] -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 0.0 constants[0] = 1.0 diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 48ab41d0c..dfad97fc7 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 428425c58..574fe07d5 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index e808d821c..3d9a8c202 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index a8a5216a2..045b53af6 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -326,7 +326,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 6.226104e-5; states[1] = 5.0; diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 911283f31..3ff58c68f 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index aa0f5640b..cd7801ddc 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -313,7 +313,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 6.226104e-5 states[1] = 5.0 states[2] = 0.409551 diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 359ef0869..ad882a9eb 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -276,7 +276,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = -39.013558536; states[1] = 0.092361701692; diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 817cb1544..7160a3fb1 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 1817e152e..9a0e9212e 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -251,7 +251,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = -39.013558536 states[1] = 0.092361701692 states[2] = 0.015905380261 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index cdeae6291..55490ad4c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index 857b7d32f..d86b4881e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index efe508ad1..a444417b1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 399b824ff..9ea08e159 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -98,7 +98,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 2e6435a24..8709c5445 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index 857b7d32f..d86b4881e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index a1324eb79..02f9149f9 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 6d271f592..a67ad8273 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index 857b7d32f..d86b4881e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index b3951a5dd..cd644acd0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 51e1dd0e2..0b1b5ec76 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -516,7 +516,7 @@ void findRoot16(double voi, double *states, double *rates, double *variables) rates[3] = u[0]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index 07842acfd..bb8c14e65 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index a42be47a5..82e45add9 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -437,7 +437,7 @@ def find_root_16(voi, states, rates, variables): rates[3] = u[0] -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index f10c3958b..29251ba2f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index 857b7d32f..d86b4881e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 716cafe93..5617153fe 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 08b086b89..3c67e6474 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index 857b7d32f..d86b4881e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 0a961a48b..03c5b15a3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 45f29d072..e4646c055 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index 857b7d32f..d86b4881e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 7fb9fbb6f..522d0795d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index f5f5a253f..bceb90099 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.6; states[1] = 0.325; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index 857b7d32f..d86b4881e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index cb704989d..d6e3ae27c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.6 states[1] = 0.325 constants[0] = 1.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 4dd384571..452d243d2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.6; states[1] = 0.05; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index 857b7d32f..d86b4881e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index fd8453ffc..199dab37b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.6 states[1] = 0.05 states[2] = 0.325 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index 07842acfd..bb8c14e65 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 2a50b6d32..5e4544aff 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -77,7 +77,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 205334d7b..b9b6ea788 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index 857b7d32f..d86b4881e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index b97e82403..1e9f9cf9c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.325 diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index e827ed239..01b5b73f8 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -97,7 +97,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = -87.0; states[1] = 0.01; diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index e3b78b41d..dd78b8573 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 787e9a973..886e83180 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -64,7 +64,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = -87.0 states[1] = 0.01 states[2] = 0.8 diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 7e82c1532..d414fe9c3 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index e29840b4e..a415fa4ae 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 2ac23adae..8cc8419dc 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 6c40a92a7..ae4086a65 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index d2fac6dd0..7672524c3 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 6d8e7ec5d..200410168 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index 2a6e2a5f2..c07a96c1d 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; constants[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index e29840b4e..a415fa4ae 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 82e966ec6..30e37bfff 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index 72adfdb45..535c9f232 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; constants[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index d2fac6dd0..7672524c3 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index b50178500..f9dd400b5 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index b16f44430..079b3e5ab 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index e29840b4e..a415fa4ae 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index 0341e10a4..f68edb538 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 2f0a222f8..ac1762023 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index d2fac6dd0..7672524c3 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index 0a7d4de47..d82951638 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 19903539f..504fb338c 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = -2.0; states[1] = 0.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index 723fd5403..798bab570 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index a25d71bd7..aa411806c 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = -2.0 states[1] = 0.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index ce6518100..7ce485262 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = -2.0; states[1] = 0.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index a929fb7cd..bec3e3490 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index c86ec1bb7..0b45d416c 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = -2.0 states[1] = 0.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index c1f03ce23..d176162d6 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 1.0; diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index f62cb5d15..ffe8d72ae 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 8c2596617..9b961ab38 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index 3ff8890e6..ea28a9b45 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 1.0; diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index e29840b4e..a415fa4ae 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 2da518cac..4a6a2dcf2 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 1.0 diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 4d5fa00df..0a9d6e3d0 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -117,7 +117,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[0] = u[0]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index 5d5754056..85620bec4 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 1b8fd4127..e018d745a 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -74,7 +74,7 @@ def find_root_0(voi, states, rates, variables): algebraic[0] = u[0] -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 0.0 constants[0] = 0.04 diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 27ca2adc6..c64c8f3d0 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -83,7 +83,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index 5d5754056..85620bec4 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index ef074678f..06e02a784 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -50,7 +50,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 0.0 states[2] = 0.0 diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 3d3b671d0..35e0bd5e9 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -87,7 +87,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = constants[0]; constants[0] = 0.0; diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index 25b6b8b1e..e823a9400 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 0204c1bc9..fe54908e7 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -58,7 +58,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): states[0] = constants[0] constants[0] = 0.0 constants[1] = 0.75 diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 8b023706c..4ba572946 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -84,7 +84,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { constants[0] = 1.1; constants[1] = 21262500.0; diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 3e9774145..c4d3c4020 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *variables, size_t index); -void initialiseVariables(double *constants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 4a8e5e195..bdd145f68 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -51,7 +51,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic): constants[0] = 1.1 constants[1] = 21262500.0 constants[2] = 150.0 diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 4539a6618..689d802b5 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic) +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { constants[0] = 7.0; states[0] = constants[0]; diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index ea32185a4..ce68264b3 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *algebraic); +void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 092c15be2..688fa5303 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, algebraic): +def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): constants[0] = 7.0 states[0] = constants[0] From d1020eb2edb524de086591cb4b5846fcf1dda2fa Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 19 Aug 2024 15:12:46 +0200 Subject: [PATCH 39/74] GeneratorProfile: don't need to pass the VOI to initialiseVariables(). --- src/generatorprofile.cpp | 6 +++--- src/generatorprofilesha1values.h | 4 ++-- tests/bindings/python/test_generator_profile.py | 4 ++-- tests/generator/generatorprofile.cpp | 4 ++-- tests/resources/coverage/generator/model.c | 2 +- tests/resources/coverage/generator/model.h | 2 +- tests/resources/coverage/generator/model.implementation.out | 2 +- tests/resources/coverage/generator/model.interface.out | 2 +- tests/resources/coverage/generator/model.modified.profile.c | 2 +- tests/resources/coverage/generator/model.modified.profile.h | 2 +- .../resources/coverage/generator/model.modified.profile.py | 2 +- tests/resources/coverage/generator/model.out | 2 +- tests/resources/coverage/generator/model.py | 2 +- .../generator/algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_derivative_on_rhs/model.h | 2 +- .../generator/algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs_one_component/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs_one_component/model.h | 2 +- .../algebraic_eqn_derivative_on_rhs_one_component/model.py | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.h | 2 +- .../generator/algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../algebraic_eqn_state_var_on_rhs_one_component/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs_one_component/model.h | 2 +- .../algebraic_eqn_state_var_on_rhs_one_component/model.py | 2 +- .../generator/cellml_mappings_and_encapsulations/model.c | 2 +- .../generator/cellml_mappings_and_encapsulations/model.h | 2 +- .../generator/cellml_mappings_and_encapsulations/model.py | 2 +- .../cellml_state_initialised_using_variable/model.c | 2 +- .../cellml_state_initialised_using_variable/model.h | 2 +- .../cellml_state_initialised_using_variable/model.py | 2 +- tests/resources/generator/cellml_unit_scaling_rate/model.c | 2 +- tests/resources/generator/cellml_unit_scaling_rate/model.h | 2 +- tests/resources/generator/cellml_unit_scaling_rate/model.py | 2 +- tests/resources/generator/cellml_unit_scaling_state/model.c | 2 +- tests/resources/generator/cellml_unit_scaling_state/model.h | 2 +- .../resources/generator/cellml_unit_scaling_state/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.c | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.h | 2 +- .../generator/cellml_unit_scaling_voi_direct/model.py | 2 +- .../generator/cellml_unit_scaling_voi_indirect/model.c | 2 +- .../generator/cellml_unit_scaling_voi_indirect/model.h | 2 +- .../generator/cellml_unit_scaling_voi_indirect/model.py | 2 +- tests/resources/generator/dae_cellml_1_1_model/model.c | 2 +- tests/resources/generator/dae_cellml_1_1_model/model.h | 2 +- tests/resources/generator/dae_cellml_1_1_model/model.py | 2 +- tests/resources/generator/dependent_eqns/model.c | 2 +- tests/resources/generator/dependent_eqns/model.h | 2 +- tests/resources/generator/dependent_eqns/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.algebraic.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.algebraic.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.algebraic.py | 2 +- .../generator/hodgkin_huxley_squid_axon_model_1952/model.c | 2 +- .../model.computed.constant.c | 2 +- .../model.computed.constant.h | 2 +- .../model.computed.constant.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.constant.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.constant.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.constant.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.dae.py | 2 +- .../model.dependent.algebraic.c | 2 +- .../model.dependent.algebraic.h | 2 +- .../model.dependent.algebraic.py | 2 +- .../model.dependent.computed.constant.c | 2 +- .../model.dependent.computed.constant.h | 2 +- .../model.dependent.computed.constant.py | 2 +- .../model.dependent.constant.c | 2 +- .../model.dependent.constant.h | 2 +- .../model.dependent.constant.py | 2 +- .../model.dependent.state.c | 2 +- .../model.dependent.state.h | 2 +- .../model.dependent.state.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.external.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.external.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.external.py | 2 +- .../generator/hodgkin_huxley_squid_axon_model_1952/model.h | 2 +- .../generator/hodgkin_huxley_squid_axon_model_1952/model.py | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.state.c | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.state.h | 2 +- .../hodgkin_huxley_squid_axon_model_1952/model.state.py | 2 +- tests/resources/generator/noble_model_1962/model.c | 2 +- tests/resources/generator/noble_model_1962/model.h | 2 +- tests/resources/generator/noble_model_1962/model.py | 2 +- tests/resources/generator/ode_computed_var_on_rhs/model.c | 2 +- tests/resources/generator/ode_computed_var_on_rhs/model.h | 2 +- tests/resources/generator/ode_computed_var_on_rhs/model.py | 2 +- .../generator/ode_computed_var_on_rhs_one_component/model.c | 2 +- .../generator/ode_computed_var_on_rhs_one_component/model.h | 2 +- .../ode_computed_var_on_rhs_one_component/model.py | 2 +- tests/resources/generator/ode_const_var_on_rhs/model.c | 2 +- tests/resources/generator/ode_const_var_on_rhs/model.h | 2 +- tests/resources/generator/ode_const_var_on_rhs/model.py | 2 +- .../generator/ode_const_var_on_rhs_one_component/model.c | 2 +- .../generator/ode_const_var_on_rhs_one_component/model.h | 2 +- .../generator/ode_const_var_on_rhs_one_component/model.py | 2 +- tests/resources/generator/ode_constant_on_rhs/model.c | 2 +- tests/resources/generator/ode_constant_on_rhs/model.h | 2 +- tests/resources/generator/ode_constant_on_rhs/model.py | 2 +- .../generator/ode_constant_on_rhs_one_component/model.c | 2 +- .../generator/ode_constant_on_rhs_one_component/model.h | 2 +- .../generator/ode_constant_on_rhs_one_component/model.py | 2 +- .../resources/generator/ode_multiple_dependent_odes/model.c | 2 +- .../resources/generator/ode_multiple_dependent_odes/model.h | 2 +- .../generator/ode_multiple_dependent_odes/model.py | 2 +- .../ode_multiple_dependent_odes_one_component/model.c | 2 +- .../ode_multiple_dependent_odes_one_component/model.h | 2 +- .../ode_multiple_dependent_odes_one_component/model.py | 2 +- .../generator/ode_multiple_odes_with_same_name/model.c | 2 +- .../generator/ode_multiple_odes_with_same_name/model.h | 2 +- .../generator/ode_multiple_odes_with_same_name/model.py | 2 +- tests/resources/generator/ode_unknown_var_on_rhs/model.c | 2 +- tests/resources/generator/ode_unknown_var_on_rhs/model.h | 2 +- tests/resources/generator/ode_unknown_var_on_rhs/model.py | 2 +- tests/resources/generator/robertson_model_1966/model.dae.c | 2 +- tests/resources/generator/robertson_model_1966/model.dae.h | 2 +- tests/resources/generator/robertson_model_1966/model.dae.py | 2 +- tests/resources/generator/robertson_model_1966/model.ode.c | 2 +- tests/resources/generator/robertson_model_1966/model.ode.h | 2 +- tests/resources/generator/robertson_model_1966/model.ode.py | 2 +- tests/resources/generator/sine_model_imports/model.c | 2 +- tests/resources/generator/sine_model_imports/model.h | 2 +- tests/resources/generator/sine_model_imports/model.py | 2 +- .../generator/variable_initialised_using_a_constant/model.c | 2 +- .../generator/variable_initialised_using_a_constant/model.h | 2 +- .../variable_initialised_using_a_constant/model.py | 2 +- 139 files changed, 144 insertions(+), 144 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 0179deb7f..c45912ed4 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -415,8 +415,8 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "}\n"; - mInterfaceInitialiseVariablesMethodFdmString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n"; - mImplementationInitialiseVariablesMethodFdmString = "void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + mInterfaceInitialiseVariablesMethodFdmString = "void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n"; + mImplementationInitialiseVariablesMethodFdmString = "void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n"; @@ -807,7 +807,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceInitialiseVariablesMethodFdmString = ""; mImplementationInitialiseVariablesMethodFdmString = "\n" - "def initialise_variables(voi, states, rates, constants, computed_constants, algebraic):\n" + "def initialise_variables(states, rates, constants, computed_constants, algebraic):\n" "[CODE]"; mInterfaceComputeComputedConstantsMethodString = ""; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index a208a5986..c7400228e 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "22b2ada38f83adad3e70dd776ef9d72c7c1a966f"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "405499117ed4245fbee40c3d18303ee748e3a1a2"; +static const char C_GENERATOR_PROFILE_SHA1[] = "e5477b943b378914f730fdbf8c415e662d8950e2"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "f0acab1cd54d81a14aaee315aeb7dd69ac4c7ffb"; } // namespace libcellml diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index fad40298b..22f653cbb 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -843,7 +843,7 @@ def test_implementation_initialise_constants_method_string(self): g.setImplementationInitialiseVariablesMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(False)) - self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(True)) g.setImplementationInitialiseVariablesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(True)) @@ -1122,7 +1122,7 @@ def test_interface_initialise_constants_method_string(self): g.setInterfaceInitialiseVariablesMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(False)) - self.assertEqual('void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n', + self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n', g.interfaceInitialiseVariablesMethodString(True)) g.setInterfaceInitialiseVariablesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(True)) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index ab038a263..50e26d775 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -494,9 +494,9 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationInitialiseVariablesMethodString(false)); - EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n", + EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n", generatorProfile->interfaceInitialiseVariablesMethodString(true)); - EXPECT_EQ("void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n", diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 8b52167d6..0b2f0b53f 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -405,7 +405,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index c22174b70..8f8822482 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 6a38edeaf..441505f7c 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -168,7 +168,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index a444951dc..a5fb08035 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -11,7 +11,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 5653c51ae..07afcc6af 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -405,7 +405,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 6cc99016d..df9429751 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 89ec8121c..886bbb8b7 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -383,7 +383,7 @@ def find_root_0(voi, states, rates, variables): algebraic[1] = u[1] -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 constants[0] = 1.0 constants[1] = 2.0 diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index 514bac2e1..3a2b4ea51 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -116,7 +116,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[1] = u[1]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; constants[0] = 1.0; diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index a211b39e5..113504cbe 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -383,7 +383,7 @@ def find_root_0(voi, states, rates, variables): algebraic[1] = u[1] -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 constants[0] = 1.0 constants[1] = 2.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 9c2f823f6..cd2b071d0 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index c50e027fc..f343bb87e 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 3f7bc9517..362c69198 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 8c72b66ab..7f718e1cb 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index 7672524c3..3f2f4d80f 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 598b58e85..f777d6ad3 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index 3131bc653..d532f16d2 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index 981651ccd..7ac3ea812 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index c655ba461..324e320b2 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 02014ef23..6c2e35bcb 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index 46e07c2dd..774c11663 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 013484cee..b787f96f7 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index dfeedb00f..cc55be1bf 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index d668e10ba..6841a14e8 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index cde62f28c..525f3fbaf 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -47,7 +47,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 0.0 diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index ac395dd3b..843885850 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { constants[0] = 123.0; states[0] = constants[0]; diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index 125d289e6..226dd4b8f 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index f2e9eb525..7250839ba 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): constants[0] = 123.0 states[0] = constants[0] diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 604d08c5f..015e96a45 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index 125d289e6..226dd4b8f 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 45678f11d..7f580b8b9 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index ac805fa9e..e124b3ff5 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index 125d289e6..226dd4b8f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index d88e7699c..00e889817 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index 5e7d345e2..3fe07aefc 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 123.0; states[1] = 0.001*789.0; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index ca1a66c12..9b6ba7ee8 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index 4bf6281a0..748208e28 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 123.0 states[1] = 0.001*789.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index d7e12ef11..90ad419ec 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { constants[0] = 123.0; states[0] = constants[0]; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 7f150918f..ec3903530 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 648e23013..22c48a1c4 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -47,7 +47,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): constants[0] = 123.0 states[0] = constants[0] constants[1] = 789.0 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index 630608791..ef1f82a58 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 3.0; states[1] = 5.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index a415fa4ae..c269dcfad 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index fa2831f8f..84696dfa1 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 3.0 states[1] = 5.0 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index 4d5382792..944482def 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 3.0; states[1] = 7.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 68f3a5146..30f79b5a2 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index 824dc3e08..0fb6f11ab 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 3.0 states[1] = 7.0 states[2] = 11.0 diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index fbf6e9c03..6b0819a99 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -146,7 +146,7 @@ void findRoot1(double voi, double *states, double *rates, double *variables) algebraic[4] = u[0]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 4aeac109d..ad06e8560 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 55f5a6153..ef14cb9e3 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -100,7 +100,7 @@ def find_root_1(voi, states, rates, variables): algebraic[4] = u[0] -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 0.0 constants[0] = 1.0 diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index dfad97fc7..e646340a2 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 574fe07d5..ab8b19723 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index 3d9a8c202..13aa1f785 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 045b53af6..1a000b924 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -326,7 +326,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 6.226104e-5; states[1] = 5.0; diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 3ff58c68f..7f6f6b542 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index cd7801ddc..eab12072b 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -313,7 +313,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 6.226104e-5 states[1] = 5.0 states[2] = 0.409551 diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index ad882a9eb..1251fc511 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -276,7 +276,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = -39.013558536; states[1] = 0.092361701692; diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 7160a3fb1..eed1a4a76 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 9a0e9212e..15377776c 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -251,7 +251,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = -39.013558536 states[1] = 0.092361701692 states[2] = 0.015905380261 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 55490ad4c..3a449edd1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index d86b4881e..1ba9603cc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index a444417b1..7e9218d84 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 9ea08e159..40a4e3431 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -98,7 +98,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 8709c5445..abf11523e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index d86b4881e..1ba9603cc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 02f9149f9..66a555dfb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index a67ad8273..0b61cfd4b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index d86b4881e..1ba9603cc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index cd644acd0..30ac1e478 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 0b1b5ec76..a940fe5cf 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -516,7 +516,7 @@ void findRoot16(double voi, double *states, double *rates, double *variables) rates[3] = u[0]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index bb8c14e65..1edf0a208 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 82e45add9..9d57d7855 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -437,7 +437,7 @@ def find_root_16(voi, states, rates, variables): rates[3] = u[0] -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 29251ba2f..174c5d1c5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index d86b4881e..1ba9603cc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 5617153fe..db89293eb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 3c67e6474..9e73eb2cb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index d86b4881e..1ba9603cc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 03c5b15a3..42ab91f87 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index e4646c055..8c7192206 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index d86b4881e..1ba9603cc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 522d0795d..88ab261a3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index bceb90099..b41fa29b6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.6; states[1] = 0.325; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index d86b4881e..1ba9603cc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index d6e3ae27c..47adbb19b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.6 states[1] = 0.325 constants[0] = 1.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 452d243d2..a57d9f040 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.6; states[1] = 0.05; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index d86b4881e..1ba9603cc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 199dab37b..2f58c315a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.6 states[1] = 0.05 states[2] = 0.325 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index bb8c14e65..1edf0a208 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 5e4544aff..c32bbcaf5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -77,7 +77,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index b9b6ea788..7ea8984c3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index d86b4881e..1ba9603cc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 1e9f9cf9c..5963bee10 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -85,7 +85,7 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 states[1] = 0.6 states[2] = 0.325 diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 01b5b73f8..5ff0e01c5 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -97,7 +97,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = -87.0; states[1] = 0.01; diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index dd78b8573..34f47c14f 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 886e83180..9929159d4 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -64,7 +64,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = -87.0 states[1] = 0.01 states[2] = 0.8 diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index d414fe9c3..74675869d 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index a415fa4ae..c269dcfad 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 8cc8419dc..f01c8fa21 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index ae4086a65..2c0aae0bb 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index 7672524c3..3f2f4d80f 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 200410168..e18daee17 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index c07a96c1d..c44536b88 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; constants[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index a415fa4ae..c269dcfad 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 30e37bfff..81636d01b 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index 535c9f232..0aa1714bf 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; constants[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index 7672524c3..3f2f4d80f 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index f9dd400b5..33824ba52 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index 079b3e5ab..c930a7deb 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index a415fa4ae..c269dcfad 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index f68edb538..40fc73eac 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index ac1762023..e706b63f7 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index 7672524c3..3f2f4d80f 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index d82951638..f346db704 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -44,7 +44,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 504fb338c..9664d71a3 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = -2.0; states[1] = 0.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index 798bab570..941110a71 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index aa411806c..e349f1ef5 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = -2.0 states[1] = 0.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 7ce485262..a466e7218 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = -2.0; states[1] = 0.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index bec3e3490..6bf82d149 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 0b45d416c..b56414b1b 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = -2.0 states[1] = 0.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index d176162d6..bdb58093c 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 1.0; diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index ffe8d72ae..a8f42ef1b 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 9b961ab38..e08f2c0f8 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -46,7 +46,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index ea28a9b45..9a10f6f5c 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 1.0; diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index a415fa4ae..c269dcfad 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 4a6a2dcf2..65e64eb3c 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 1.0 diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 0a9d6e3d0..9f90b3f9c 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -117,7 +117,7 @@ void findRoot0(double voi, double *states, double *rates, double *variables) algebraic[0] = u[0]; } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index 85620bec4..3eb2e01f1 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index e018d745a..512fd8d9f 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -74,7 +74,7 @@ def find_root_0(voi, states, rates, variables): algebraic[0] = u[0] -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 0.0 constants[0] = 0.04 diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index c64c8f3d0..dc3ae1892 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -83,7 +83,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index 85620bec4..3eb2e01f1 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 06e02a784..b3811cff7 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -50,7 +50,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 1.0 states[1] = 0.0 states[2] = 0.0 diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 35e0bd5e9..d1f9227a3 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -87,7 +87,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = constants[0]; constants[0] = 0.0; diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index e823a9400..f54dd00c0 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index fe54908e7..e1b66e7db 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -58,7 +58,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = constants[0] constants[0] = 0.0 constants[1] = 0.75 diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 689d802b5..dfa747712 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { constants[0] = 7.0; states[0] = constants[0]; diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index ce68264b3..932dd3aa6 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -31,7 +31,7 @@ double * createAlgebraicArray(); void deleteArray(double *array); -void initialiseVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 688fa5303..a0ea05ad7 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -45,7 +45,7 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT -def initialise_variables(voi, states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic): constants[0] = 7.0 states[0] = constants[0] From f3bbce337d51c0ad10639dd1864ea7aa95c7d756 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 19 Aug 2024 16:01:23 +0200 Subject: [PATCH 40/74] Tests: removed unneeded generated C/Python files. --- tests/generator/generator.cpp | 8 +- ...del.three.externals.c => model.external.c} | 2 +- ...del.three.externals.h => model.external.h} | 0 ...l.three.externals.py => model.external.py} | 0 .../model.one.external.c | 85 ------------ .../model.one.external.h | 37 ------ .../model.one.external.py | 71 ---------- .../model.two.externals.c | 125 ------------------ .../model.two.externals.h | 37 ------ .../model.two.externals.py | 105 --------------- 10 files changed, 5 insertions(+), 465 deletions(-) rename tests/resources/generator/algebraic_system_with_three_linked_unknowns/{model.three.externals.c => model.external.c} (98%) rename tests/resources/generator/algebraic_system_with_three_linked_unknowns/{model.three.externals.h => model.external.h} (100%) rename tests/resources/generator/algebraic_system_with_three_linked_unknowns/{model.three.externals.py => model.external.py} (100%) delete mode 100644 tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c delete mode 100644 tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h delete mode 100644 tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py delete mode 100644 tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c delete mode 100644 tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h delete mode 100644 tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index 9bfab3e60..52ccea486 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -412,16 +412,16 @@ TEST(Generator, algebraicSystemWithThreeLinkedUnknownsWithThreeExternalVariables auto profile = generator->profile(); - profile->setInterfaceFileNameString("model.three.externals.h"); + profile->setInterfaceFileNameString("model.external.h"); - EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h", generator->interfaceCode()); - EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c", generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.external.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.external.c", generator->implementationCode()); profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py", generator->implementationCode()); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.external.py", generator->implementationCode()); } TEST(Generator, algebraicSystemWithVariousDependenciesOrdered) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c similarity index 98% rename from tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c rename to tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c index bc5780016..38c67fb56 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c @@ -1,6 +1,6 @@ /* The content of this file was generated using the C profile of libCellML 0.5.0. */ -#include "model.three.externals.h" +#include "model.external.h" #include #include diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h similarity index 100% rename from tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.h rename to tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py similarity index 100% rename from tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.three.externals.py rename to tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c deleted file mode 100644 index 46aff4ae6..000000000 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.c +++ /dev/null @@ -1,85 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.5.0. */ - -#include "model.one.external.h" - -#include -#include - -const char VERSION[] = "0.6.0"; -const char LIBCELLML_VERSION[] = "0.5.0"; - -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 3; - -const VariableInfo VARIABLE_INFO[] = { - {"x", "dimensionless", "my_algebraic_system", EXTERNAL}, - {"y", "dimensionless", "my_algebraic_system", ALGEBRAIC}, - {"z", "dimensionless", "my_algebraic_system", ALGEBRAIC} -}; - -double * createVariablesArray() -{ - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); - - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { - res[i] = NAN; - } - - return res; -} - -void deleteArray(double *array) -{ - free(array); -} - -typedef struct { - double *variables; -} RootFindingInfo; - -extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), - double *u, size_t n, void *data); - -void objectiveFunction0(double *u, double *f, void *data) -{ - double *variables = ((RootFindingInfo *) data)->variables; - - variables[1] = u[0]; - variables[2] = u[1]; - - f[0] = 2.0*variables[0]+variables[1]-2.0*variables[2]-(-1.0); - f[1] = 3.0*variables[0]-3.0*variables[1]-variables[2]-5.0; - f[2] = variables[0]-2.0*variables[1]+3.0*variables[2]-6.0; -} - -void findRoot0(double *variables) -{ - RootFindingInfo rfi = { variables }; - double u[2]; - - u[0] = variables[1]; - u[1] = variables[2]; - - nlaSolve(objectiveFunction0, u, 2, &rfi); - - variables[1] = u[0]; - variables[2] = u[1]; -} - -void initialiseVariables(double *constants, ExternalVariable externalVariable) -{ - variables[1] = 1.0; - variables[2] = 1.0; - variables[0] = externalVariable(variables, 0); -} - -void computeComputedConstants(double *constants, double *computedConstants) -{ -} - -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) -{ - variables[0] = externalVariable(variables, 0); - findRoot0(variables); -} diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h deleted file mode 100644 index f8cc4af0b..000000000 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.h +++ /dev/null @@ -1,37 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.5.0. */ - -#pragma once - -#include - -extern const char VERSION[]; -extern const char LIBCELLML_VERSION[]; - -extern const size_t CONSTANT_COUNT; -extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; - -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - -typedef struct { - char name[2]; - char units[14]; - char component[20]; - VariableType type; -} VariableInfo; - -extern const VariableInfo VARIABLE_INFO[]; - -double * createVariablesArray(); -void deleteArray(double *array); - -typedef double (* ExternalVariable)(double *variables, size_t index); - -void initialiseVariables(double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py deleted file mode 100644 index bd566aa08..000000000 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.one.external.py +++ /dev/null @@ -1,71 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.5.0. - -from enum import Enum -from math import * - - -__version__ = "0.5.0" -LIBCELLML_VERSION = "0.5.0" - -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 3 - - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - EXTERNAL = 3 - - -VARIABLE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.EXTERNAL}, - {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, - {"name": "z", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC} -] - - -def create_variables_array(): - return [nan]*VARIABLE_COUNT - - -from nlasolver import nla_solve - - -def objective_function_0(u, f, data): - variables = data[0] - - variables[1] = u[0] - variables[2] = u[1] - - f[0] = 2.0*variables[0]+variables[1]-2.0*variables[2]-(-1.0) - f[1] = 3.0*variables[0]-3.0*variables[1]-variables[2]-5.0 - f[2] = variables[0]-2.0*variables[1]+3.0*variables[2]-6.0 - - -def find_root_0(variables): - u = [nan]*2 - - u[0] = variables[1] - u[1] = variables[2] - - u = nla_solve(objective_function_0, u, 2, [variables]) - - variables[1] = u[0] - variables[2] = u[1] - - -def initialise_variables(constants, external_variable): - variables[1] = 1.0 - variables[2] = 1.0 - variables[0] = external_variable(variables, 0) - - -def compute_computed_constants(constants, computed_constants): - pass - - -def compute_variables(constants, computed_constants, algebraic, external_variable): - variables[0] = external_variable(variables, 0) - find_root_0(variables) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c deleted file mode 100644 index 797c82c58..000000000 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.c +++ /dev/null @@ -1,125 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.5.0. */ - -#include "model.two.externals.h" - -#include -#include - -const char VERSION[] = "0.6.0"; -const char LIBCELLML_VERSION[] = "0.5.0"; - -const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 3; - -const VariableInfo VARIABLE_INFO[] = { - {"x", "dimensionless", "my_algebraic_system", EXTERNAL}, - {"y", "dimensionless", "my_algebraic_system", ALGEBRAIC}, - {"z", "dimensionless", "my_algebraic_system", EXTERNAL} -}; - -double * createVariablesArray() -{ - double *res = (double *) malloc(VARIABLE_COUNT*sizeof(double)); - - for (size_t i = 0; i < VARIABLE_COUNT; ++i) { - res[i] = NAN; - } - - return res; -} - -void deleteArray(double *array) -{ - free(array); -} - -typedef struct { - double *variables; -} RootFindingInfo; - -extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), - double *u, size_t n, void *data); - -void objectiveFunction0(double *u, double *f, void *data) -{ - double *variables = ((RootFindingInfo *) data)->variables; - - variables[1] = u[0]; - - f[0] = 2.0*variables[0]+variables[1]-2.0*variables[2]-(-1.0); -} - -void findRoot0(double *variables) -{ - RootFindingInfo rfi = { variables }; - double u[1]; - - u[0] = variables[1]; - - nlaSolve(objectiveFunction0, u, 1, &rfi); - - variables[1] = u[0]; -} - -void objectiveFunction1(double *u, double *f, void *data) -{ - double *variables = ((RootFindingInfo *) data)->variables; - - variables[1] = u[0]; - - f[0] = 3.0*variables[0]-3.0*variables[1]-variables[2]-5.0; -} - -void findRoot1(double *variables) -{ - RootFindingInfo rfi = { variables }; - double u[1]; - - u[0] = variables[1]; - - nlaSolve(objectiveFunction1, u, 1, &rfi); - - variables[1] = u[0]; -} - -void objectiveFunction2(double *u, double *f, void *data) -{ - double *variables = ((RootFindingInfo *) data)->variables; - - variables[1] = u[0]; - - f[0] = variables[0]-2.0*variables[1]+3.0*variables[2]-6.0; -} - -void findRoot2(double *variables) -{ - RootFindingInfo rfi = { variables }; - double u[1]; - - u[0] = variables[1]; - - nlaSolve(objectiveFunction2, u, 1, &rfi); - - variables[1] = u[0]; -} - -void initialiseVariables(double *constants, ExternalVariable externalVariable) -{ - variables[1] = 1.0; - variables[0] = externalVariable(variables, 0); - variables[2] = externalVariable(variables, 2); -} - -void computeComputedConstants(double *constants, double *computedConstants) -{ -} - -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) -{ - variables[0] = externalVariable(variables, 0); - variables[2] = externalVariable(variables, 2); - findRoot0(variables); - findRoot1(variables); - findRoot2(variables); -} diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h deleted file mode 100644 index f8cc4af0b..000000000 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.h +++ /dev/null @@ -1,37 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.5.0. */ - -#pragma once - -#include - -extern const char VERSION[]; -extern const char LIBCELLML_VERSION[]; - -extern const size_t CONSTANT_COUNT; -extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; - -typedef enum { - CONSTANT, - COMPUTED_CONSTANT, - ALGEBRAIC, - EXTERNAL -} VariableType; - -typedef struct { - char name[2]; - char units[14]; - char component[20]; - VariableType type; -} VariableInfo; - -extern const VariableInfo VARIABLE_INFO[]; - -double * createVariablesArray(); -void deleteArray(double *array); - -typedef double (* ExternalVariable)(double *variables, size_t index); - -void initialiseVariables(double *constants, ExternalVariable externalVariable); -void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py deleted file mode 100644 index 3ce4e8ff0..000000000 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.two.externals.py +++ /dev/null @@ -1,105 +0,0 @@ -# The content of this file was generated using the Python profile of libCellML 0.5.0. - -from enum import Enum -from math import * - - -__version__ = "0.5.0" -LIBCELLML_VERSION = "0.5.0" - -CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 3 - - -class VariableType(Enum): - CONSTANT = 0 - COMPUTED_CONSTANT = 1 - ALGEBRAIC = 2 - EXTERNAL = 3 - - -VARIABLE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.EXTERNAL}, - {"name": "y", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.ALGEBRAIC}, - {"name": "z", "units": "dimensionless", "component": "my_algebraic_system", "type": VariableType.EXTERNAL} -] - - -def create_variables_array(): - return [nan]*VARIABLE_COUNT - - -from nlasolver import nla_solve - - -def objective_function_0(u, f, data): - variables = data[0] - - variables[1] = u[0] - - f[0] = 2.0*variables[0]+variables[1]-2.0*variables[2]-(-1.0) - - -def find_root_0(variables): - u = [nan]*1 - - u[0] = variables[1] - - u = nla_solve(objective_function_0, u, 1, [variables]) - - variables[1] = u[0] - - -def objective_function_1(u, f, data): - variables = data[0] - - variables[1] = u[0] - - f[0] = 3.0*variables[0]-3.0*variables[1]-variables[2]-5.0 - - -def find_root_1(variables): - u = [nan]*1 - - u[0] = variables[1] - - u = nla_solve(objective_function_1, u, 1, [variables]) - - variables[1] = u[0] - - -def objective_function_2(u, f, data): - variables = data[0] - - variables[1] = u[0] - - f[0] = variables[0]-2.0*variables[1]+3.0*variables[2]-6.0 - - -def find_root_2(variables): - u = [nan]*1 - - u[0] = variables[1] - - u = nla_solve(objective_function_2, u, 1, [variables]) - - variables[1] = u[0] - - -def initialise_variables(constants, external_variable): - variables[1] = 1.0 - variables[0] = external_variable(variables, 0) - variables[2] = external_variable(variables, 2) - - -def compute_computed_constants(constants, computed_constants): - pass - - -def compute_variables(constants, computed_constants, algebraic, external_variable): - variables[0] = external_variable(variables, 0) - variables[2] = external_variable(variables, 2) - find_root_0(variables) - find_root_1(variables) - find_root_2(variables) From 1f0963079497f768749ecbcfc72a83872a4a5ce4 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 19 Aug 2024 18:39:41 +0200 Subject: [PATCH 41/74] Generator: make sure that constants are initialised when they are needed to initialise a state. --- src/generator.cpp | 25 ++++++++++++++----- .../generator/sine_model_imports/model.c | 2 +- .../generator/sine_model_imports/model.py | 2 +- 3 files changed, 21 insertions(+), 8 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index f11c2e000..9def5a35f 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1821,16 +1821,29 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st for (const auto &state : mModel->states()) { auto initialisingVariable = state->initialisingVariable(); auto initialValue = initialisingVariable->initialValue(); + auto constant = constants.end(); - if (!isCellMLReal(initialValue)) { - auto constant = std::find_if(constants.begin(), constants.end(), - [=](const AnalyserVariablePtr &av) -> bool { return av->variable()->name() == initialValue; }); + while (!isCellMLReal(initialValue)) { + // The initial value references another variable, so look for it keeping in mind that its initial value may + // reference another variable, and so on. - if (constant != constants.end()) { - methodBody += generateInitialisationCode(*constant); + auto initialisingComponent = owningComponent(initialisingVariable); + auto crtConstant = std::find_if(constants.begin(), constants.end(), + [=](const AnalyserVariablePtr &av) -> bool { return initialisingComponent->variable(initialValue)->hasEquivalentVariable(av->variable()); }); - constants.erase(constant); + if (crtConstant == constants.end()) { + break; } + + constant = crtConstant; + initialisingVariable = (*constant)->variable(); + initialValue = initialisingVariable->initialValue(); + } + + if (constant != constants.end()) { + methodBody += generateInitialisationCode(*constant); + + constants.erase(constant); } methodBody += generateInitialisationCode(state); diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index d1f9227a3..990a16ce2 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -89,8 +89,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - states[0] = constants[0]; constants[0] = 0.0; + states[0] = constants[0]; constants[1] = 0.75; computedConstants[0] = 2.0/3.14159265358979; computedConstants[1] = 2.0*3.14159265358979; diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index e1b66e7db..4bbacc477 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -59,8 +59,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, computed_constants, algebraic): - states[0] = constants[0] constants[0] = 0.0 + states[0] = constants[0] constants[1] = 0.75 computed_constants[0] = 2.0/3.14159265358979 computed_constants[1] = 2.0*3.14159265358979 From b54f6889d5b0c57402160779683640722526d9ad Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 19 Aug 2024 22:30:29 +0200 Subject: [PATCH 42/74] GeneratorProfile: use the constants, computed constants, and algebraic arrays rather than the variables array with findRoot() & Co. --- src/generatorprofile.cpp | 48 ++-- src/generatorprofilesha1values.h | 4 +- .../bindings/python/test_generator_profile.py | 16 +- tests/generator/generatorprofile.cpp | 28 ++- tests/resources/coverage/generator/model.c | 14 +- .../generator/model.implementation.out | 14 +- .../generator/model.modified.profile.c | 14 +- .../generator/model.modified.profile.py | 10 +- tests/resources/coverage/generator/model.out | 12 +- tests/resources/coverage/generator/model.py | 10 +- .../model.c | 14 +- .../model.py | 10 +- .../model.c | 14 +- .../model.py | 10 +- .../model.not.ordered.c | 14 +- .../model.not.ordered.py | 10 +- .../model.ordered.c | 14 +- .../model.ordered.py | 10 +- .../generator/dae_cellml_1_1_model/model.c | 28 ++- .../generator/dae_cellml_1_1_model/model.py | 24 +- .../model.dae.c | 208 ++++++++++-------- .../model.dae.py | 204 ++++++++++------- .../robertson_model_1966/model.dae.c | 16 +- .../robertson_model_1966/model.dae.py | 12 +- 24 files changed, 454 insertions(+), 304 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index c45912ed4..db36f888c 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -297,28 +297,32 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mExternalVariableMethodCallFdmString = "externalVariable(voi, states, rates, variables, [INDEX])"; mRootFindingInfoObjectFamString = "typedef struct {\n" - " double *variables;\n" + " double *constants;\n" + " double *computedConstants;\n" + " double *algebraic;\n" "} RootFindingInfo;\n"; mRootFindingInfoObjectFdmString = "typedef struct {\n" " double voi;\n" " double *states;\n" " double *rates;\n" - " double *variables;\n" + " double *constants;\n" + " double *computedConstants;\n" + " double *algebraic;\n" "} RootFindingInfo;\n"; mExternNlaSolveMethodString = "extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *),\n" " double *u, size_t n, void *data);\n"; - mFindRootCallFamString = "findRoot[INDEX](variables);\n"; - mFindRootCallFdmString = "findRoot[INDEX](voi, states, rates, variables);\n"; - mFindRootMethodFamString = "void findRoot[INDEX](double *variables)\n" + mFindRootCallFamString = "findRoot[INDEX](constants, computedConstants, algebraic);\n"; + mFindRootCallFdmString = "findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic);\n"; + mFindRootMethodFamString = "void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic)\n" "{\n" - " RootFindingInfo rfi = { variables };\n" + " RootFindingInfo rfi = { constants, computedConstants, algebraic };\n" " double u[[SIZE]];\n" "\n" "[CODE]" "}\n"; - mFindRootMethodFdmString = "void findRoot[INDEX](double voi, double *states, double *rates, double *variables)\n" + mFindRootMethodFdmString = "void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" "{\n" - " RootFindingInfo rfi = { voi, states, rates, variables };\n" + " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic };\n" " double u[[SIZE]];\n" "\n" "[CODE]" @@ -327,7 +331,9 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mNlaSolveCallFdmString = "nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n"; mObjectiveFunctionMethodFamString = "void objectiveFunction[INDEX](double *u, double *f, void *data)\n" "{\n" - " double *variables = ((RootFindingInfo *) data)->variables;\n" + " double *constants = ((RootFindingInfo *) data)->constants;\n" + " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" + " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" "\n" "[CODE]" "}\n"; @@ -336,7 +342,9 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " double voi = ((RootFindingInfo *) data)->voi;\n" " double *states = ((RootFindingInfo *) data)->states;\n" " double *rates = ((RootFindingInfo *) data)->rates;\n" - " double *variables = ((RootFindingInfo *) data)->variables;\n" + " double *constants = ((RootFindingInfo *) data)->constants;\n" + " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" + " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" "\n" "[CODE]" "}\n"; @@ -742,23 +750,25 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mExternNlaSolveMethodString = "\n" "from nlasolver import nla_solve" "\n"; - mFindRootCallFamString = "find_root_[INDEX](variables)\n"; - mFindRootCallFdmString = "find_root_[INDEX](voi, states, rates, variables)\n"; + mFindRootCallFamString = "find_root_[INDEX](constants, computed_constants, algebraic)\n"; + mFindRootCallFdmString = "find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic)\n"; mFindRootMethodFamString = "\n" - "def find_root_[INDEX](variables):\n" + "def find_root_[INDEX](constants, computed_constants, algebraic):\n" " u = [nan]*[SIZE]\n" "\n" "[CODE]"; mFindRootMethodFdmString = "\n" - "def find_root_[INDEX](voi, states, rates, variables):\n" + "def find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic):\n" " u = [nan]*[SIZE]\n" "\n" "[CODE]"; - mNlaSolveCallFamString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [variables])\n"; - mNlaSolveCallFdmString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [voi, states, rates, variables])\n"; + mNlaSolveCallFamString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [constants, computed_constants, algebraic])\n"; + mNlaSolveCallFdmString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [voi, states, rates, constants, computed_constants, algebraic])\n"; mObjectiveFunctionMethodFamString = "\n" "def objective_function_[INDEX](u, f, data):\n" - " variables = data[0]\n" + " constants = data[0]\n" + " computed_constants = data[1]\n" + " algebraic = data[2]\n" "\n" "[CODE]"; mObjectiveFunctionMethodFdmString = "\n" @@ -766,7 +776,9 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " voi = data[0]\n" " states = data[1]\n" " rates = data[2]\n" - " variables = data[3]\n" + " constants = data[3]\n" + " computed_constants = data[4]\n" + " algebraic = data[5]\n" "\n" "[CODE]"; mUArrayString = "u"; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index c7400228e..fb447d903 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "e5477b943b378914f730fdbf8c415e662d8950e2"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "f0acab1cd54d81a14aaee315aeb7dd69ac4c7ffb"; +static const char C_GENERATOR_PROFILE_SHA1[] = "d89b171278ed3bf717a6127eeb6ac6a7a90d0157"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "b5d9c5ac70bf89bf6396b8928885781b96e458ba"; } // namespace libcellml diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 22f653cbb..32b35283a 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -1708,11 +1708,11 @@ def test_root_finding_info_object_string(self): g = GeneratorProfile() - self.assertEqual('typedef struct {\n double *variables;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(False)) + self.assertEqual('typedef struct {\n double *constants;\n double *computedConstants;\n double *algebraic;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(False)) g.setRootFindingInfoObjectString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(False)) - self.assertEqual('typedef struct {\n double voi;\n double *states;\n double *rates;\n double *variables;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(True)) + self.assertEqual('typedef struct {\n double voi;\n double *states;\n double *rates;\n double *constants;\n double *computedConstants;\n double *algebraic;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(True)) g.setRootFindingInfoObjectString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(True)) @@ -1730,11 +1730,11 @@ def test_find_root_call_string(self): g = GeneratorProfile() - self.assertEqual('findRoot[INDEX](variables);\n', g.findRootCallString(False)) + self.assertEqual('findRoot[INDEX](constants, computedConstants, algebraic);\n', g.findRootCallString(False)) g.setFindRootCallString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(False)) - self.assertEqual('findRoot[INDEX](voi, states, rates, variables);\n', g.findRootCallString(True)) + self.assertEqual('findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic);\n', g.findRootCallString(True)) g.setFindRootCallString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(True)) @@ -1743,11 +1743,11 @@ def test_find_root_method_string(self): g = GeneratorProfile() - self.assertEqual('void findRoot[INDEX](double *variables)\n{\n RootFindingInfo rfi = { variables };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(False)) + self.assertEqual('void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic)\n{\n RootFindingInfo rfi = { constants, computedConstants, algebraic };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(False)) g.setFindRootMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(False)) - self.assertEqual('void findRoot[INDEX](double voi, double *states, double *rates, double *variables)\n{\n RootFindingInfo rfi = { voi, states, rates, variables };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(True)) + self.assertEqual('void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(True)) g.setFindRootMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(True)) @@ -1769,11 +1769,11 @@ def test_objective_function_method_string(self): g = GeneratorProfile() - self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double *variables = ((RootFindingInfo *) data)->variables;\n\n[CODE]}\n', g.objectiveFunctionMethodString(False)) + self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n\n[CODE]}\n', g.objectiveFunctionMethodString(False)) g.setObjectiveFunctionMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(False)) - self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double voi = ((RootFindingInfo *) data)->voi;\n double *states = ((RootFindingInfo *) data)->states;\n double *rates = ((RootFindingInfo *) data)->rates;\n double *variables = ((RootFindingInfo *) data)->variables;\n\n[CODE]}\n', g.objectiveFunctionMethodString(True)) + self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double voi = ((RootFindingInfo *) data)->voi;\n double *states = ((RootFindingInfo *) data)->states;\n double *rates = ((RootFindingInfo *) data)->rates;\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n\n[CODE]}\n', g.objectiveFunctionMethodString(True)) g.setObjectiveFunctionMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(True)) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 50e26d775..4cc9c6412 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -349,34 +349,38 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("externalVariable(voi, states, rates, variables, [INDEX])", generatorProfile->externalVariableMethodCallString(true)); EXPECT_EQ("typedef struct {\n" - " double *variables;\n" + " double *constants;\n" + " double *computedConstants;\n" + " double *algebraic;\n" "} RootFindingInfo;\n", generatorProfile->rootFindingInfoObjectString(false)); EXPECT_EQ("typedef struct {\n" " double voi;\n" " double *states;\n" " double *rates;\n" - " double *variables;\n" + " double *constants;\n" + " double *computedConstants;\n" + " double *algebraic;\n" "} RootFindingInfo;\n", generatorProfile->rootFindingInfoObjectString(true)); EXPECT_EQ("extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *),\n" " double *u, size_t n, void *data);\n", generatorProfile->externNlaSolveMethodString()); - EXPECT_EQ("findRoot[INDEX](variables);\n", + EXPECT_EQ("findRoot[INDEX](constants, computedConstants, algebraic);\n", generatorProfile->findRootCallString(false)); - EXPECT_EQ("findRoot[INDEX](voi, states, rates, variables);\n", + EXPECT_EQ("findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic);\n", generatorProfile->findRootCallString(true)); - EXPECT_EQ("void findRoot[INDEX](double *variables)\n" + EXPECT_EQ("void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic)\n" "{\n" - " RootFindingInfo rfi = { variables };\n" + " RootFindingInfo rfi = { constants, computedConstants, algebraic };\n" " double u[[SIZE]];\n" "\n" "[CODE]" "}\n", generatorProfile->findRootMethodString(false)); - EXPECT_EQ("void findRoot[INDEX](double voi, double *states, double *rates, double *variables)\n" + EXPECT_EQ("void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" "{\n" - " RootFindingInfo rfi = { voi, states, rates, variables };\n" + " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic };\n" " double u[[SIZE]];\n" "\n" "[CODE]" @@ -388,7 +392,9 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) generatorProfile->nlaSolveCallString(true)); EXPECT_EQ("void objectiveFunction[INDEX](double *u, double *f, void *data)\n" "{\n" - " double *variables = ((RootFindingInfo *) data)->variables;\n" + " double *constants = ((RootFindingInfo *) data)->constants;\n" + " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" + " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" "\n" "[CODE]" "}\n", @@ -398,7 +404,9 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) " double voi = ((RootFindingInfo *) data)->voi;\n" " double *states = ((RootFindingInfo *) data)->states;\n" " double *rates = ((RootFindingInfo *) data)->rates;\n" - " double *variables = ((RootFindingInfo *) data)->variables;\n" + " double *constants = ((RootFindingInfo *) data)->constants;\n" + " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" + " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" "\n" "[CODE]" "}\n", diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 0b2f0b53f..cdfe71e11 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -371,7 +371,9 @@ typedef struct { double voi; double *states; double *rates; - double *variables; + double *constants; + double *computedConstants; + double *algebraic; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -382,7 +384,9 @@ void objectiveFunction0(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[0] = u[0]; algebraic[1] = u[1]; @@ -391,9 +395,9 @@ void objectiveFunction0(double *u, double *f, void *data) f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); } -void findRoot0(double voi, double *states, double *rates, double *variables) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[2]; u[0] = algebraic[0]; @@ -630,5 +634,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - findRoot0(voi, states, rates, variables); + findRoot0(voi, states, rates, constants, computedConstants, algebraic); } diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 441505f7c..c969013df 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -134,7 +134,9 @@ typedef struct { double voi; double *states; double *rates; - double *variables; + double *constants; + double *computedConstants; + double *algebraic; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -145,7 +147,9 @@ void objectiveFunction0(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[0] = u[0]; algebraic[1] = u[1]; @@ -154,9 +158,9 @@ void objectiveFunction0(double *u, double *f, void *data) f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); } -void findRoot0(double voi, double *states, double *rates, double *variables) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[2]; u[0] = algebraic[0]; @@ -393,5 +397,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - findRoot0(voi, states, rates, variables); + findRoot0(voi, states, rates, constants, computedConstants, algebraic); } diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 07afcc6af..5c6e1d9fd 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -371,7 +371,9 @@ typedef struct { double voi; double *states; double *rates; - double *variables; + double *constants; + double *computedConstants; + double *algebraic; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -382,7 +384,9 @@ void objectiveFunction0(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[0] = u[0]; algebraic[1] = u[1]; @@ -391,9 +395,9 @@ void objectiveFunction0(double *u, double *f, void *data) f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); } -void findRoot0(double voi, double *states, double *rates, double *variables) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[2]; u[0] = algebraic[0]; @@ -630,5 +634,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - findRoot0(voi, states, rates, variables); + findRoot0(voi, states, rates, constants, computedConstants, algebraic); } diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 886bbb8b7..4c224613d 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -362,7 +362,9 @@ def objective_function_0(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[0] = u[0] algebraic[1] = u[1] @@ -371,13 +373,13 @@ def objective_function_0(u, f, data): f[1] = algebraic[0]-algebraic[1]-(computed_constants[198]+computed_constants[199]) -def find_root_0(voi, states, rates, variables): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*2 u[0] = algebraic[0] u[1] = algebraic[1] - u = nla_solve(objective_function_0, u, 2, [voi, states, rates, variables]) + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[0] = u[0] algebraic[1] = u[1] @@ -604,4 +606,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - find_root_0(voi, states, rates, variables) + find_root_0(voi, states, rates, constants, computed_constants, algebraic) diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index 3a2b4ea51..acd776c9f 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -82,7 +82,9 @@ typedef struct { double voi; double *states; double *rates; - double *variables; + double *constants; + double *computedConstants; + double *algebraic; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -93,7 +95,9 @@ void objectiveFunction0(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[0] = u[0]; algebraic[1] = u[1]; @@ -102,9 +106,9 @@ void objectiveFunction0(double *u, double *f, void *data) f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); } -void findRoot0(double voi, double *states, double *rates, double *variables) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[2]; u[0] = algebraic[0]; diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 113504cbe..779814e80 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -362,7 +362,9 @@ def objective_function_0(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[0] = u[0] algebraic[1] = u[1] @@ -371,13 +373,13 @@ def objective_function_0(u, f, data): f[1] = algebraic[0]-algebraic[1]-(computed_constants[198]+computed_constants[199]) -def find_root_0(voi, states, rates, variables): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*2 u[0] = algebraic[0] u[1] = algebraic[1] - u = nla_solve(objective_function_0, u, 2, [voi, states, rates, variables]) + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[0] = u[0] algebraic[1] = u[1] @@ -604,4 +606,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - find_root_0(voi, states, rates, variables) + find_root_0(voi, states, rates, constants, computed_constants, algebraic) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index bd2b6cf18..1841f66b0 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -64,7 +64,9 @@ void deleteArray(double *array) } typedef struct { - double *variables; + double *constants; + double *computedConstants; + double *algebraic; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -72,16 +74,18 @@ extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), void objectiveFunction0(double *u, double *f, void *data) { - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[0] = u[0]; f[0] = algebraic[0]+computedConstants[0]-(computedConstants[1]+computedConstants[2]); } -void findRoot0(double *variables) +void findRoot0(double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { variables }; + RootFindingInfo rfi = { constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[0]; @@ -105,5 +109,5 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic) { - findRoot0(variables); + findRoot0(constants, computedConstants, algebraic); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 199da80a2..0e3d3346d 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -41,19 +41,21 @@ def create_algebraic_array(): def objective_function_0(u, f, data): - variables = data[0] + constants = data[0] + computed_constants = data[1] + algebraic = data[2] algebraic[0] = u[0] f[0] = algebraic[0]+computed_constants[0]-(computed_constants[1]+computed_constants[2]) -def find_root_0(variables): +def find_root_0(constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[0] - u = nla_solve(objective_function_0, u, 1, [variables]) + u = nla_solve(objective_function_0, u, 1, [constants, computed_constants, algebraic]) algebraic[0] = u[0] @@ -70,4 +72,4 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic): - find_root_0(variables) + find_root_0(constants, computed_constants, algebraic) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index f2362c836..6d4d78db8 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -63,7 +63,9 @@ void deleteArray(double *array) } typedef struct { - double *variables; + double *constants; + double *computedConstants; + double *algebraic; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -71,7 +73,9 @@ extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), void objectiveFunction0(double *u, double *f, void *data) { - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[0] = u[0]; algebraic[1] = u[1]; @@ -82,9 +86,9 @@ void objectiveFunction0(double *u, double *f, void *data) f[2] = algebraic[0]-2.0*algebraic[1]+3.0*algebraic[2]-6.0; } -void findRoot0(double *variables) +void findRoot0(double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { variables }; + RootFindingInfo rfi = { constants, computedConstants, algebraic }; double u[3]; u[0] = algebraic[0]; @@ -111,5 +115,5 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic) { - findRoot0(variables); + findRoot0(constants, computedConstants, algebraic); } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 08b001bda..64d958922 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -40,7 +40,9 @@ def create_algebraic_array(): def objective_function_0(u, f, data): - variables = data[0] + constants = data[0] + computed_constants = data[1] + algebraic = data[2] algebraic[0] = u[0] algebraic[1] = u[1] @@ -51,14 +53,14 @@ def objective_function_0(u, f, data): f[2] = algebraic[0]-2.0*algebraic[1]+3.0*algebraic[2]-6.0 -def find_root_0(variables): +def find_root_0(constants, computed_constants, algebraic): u = [nan]*3 u[0] = algebraic[0] u[1] = algebraic[1] u[2] = algebraic[2] - u = nla_solve(objective_function_0, u, 3, [variables]) + u = nla_solve(objective_function_0, u, 3, [constants, computed_constants, algebraic]) algebraic[0] = u[0] algebraic[1] = u[1] @@ -76,4 +78,4 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic): - find_root_0(variables) + find_root_0(constants, computed_constants, algebraic) diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index eb6901bc6..c05b19145 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -66,7 +66,9 @@ void deleteArray(double *array) } typedef struct { - double *variables; + double *constants; + double *computedConstants; + double *algebraic; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -74,7 +76,9 @@ extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), void objectiveFunction0(double *u, double *f, void *data) { - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[2] = u[0]; algebraic[1] = u[1]; @@ -83,9 +87,9 @@ void objectiveFunction0(double *u, double *f, void *data) f[1] = computedConstants[0]+3.0*algebraic[1]-algebraic[2]-19.0; } -void findRoot0(double *variables) +void findRoot0(double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { variables }; + RootFindingInfo rfi = { constants, computedConstants, algebraic }; double u[2]; u[0] = algebraic[2]; @@ -112,6 +116,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic) { - findRoot0(variables); + findRoot0(constants, computedConstants, algebraic); algebraic[0] = algebraic[1]+algebraic[2]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 31584bc6c..9398a2d15 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -43,7 +43,9 @@ def create_algebraic_array(): def objective_function_0(u, f, data): - variables = data[0] + constants = data[0] + computed_constants = data[1] + algebraic = data[2] algebraic[2] = u[0] algebraic[1] = u[1] @@ -52,13 +54,13 @@ def objective_function_0(u, f, data): f[1] = computed_constants[0]+3.0*algebraic[1]-algebraic[2]-19.0 -def find_root_0(variables): +def find_root_0(constants, computed_constants, algebraic): u = [nan]*2 u[0] = algebraic[2] u[1] = algebraic[1] - u = nla_solve(objective_function_0, u, 2, [variables]) + u = nla_solve(objective_function_0, u, 2, [constants, computed_constants, algebraic]) algebraic[2] = u[0] algebraic[1] = u[1] @@ -76,5 +78,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic): - find_root_0(variables) + find_root_0(constants, computed_constants, algebraic) algebraic[0] = algebraic[1]+algebraic[2] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index f44603229..81bb63396 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -66,7 +66,9 @@ void deleteArray(double *array) } typedef struct { - double *variables; + double *constants; + double *computedConstants; + double *algebraic; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -74,7 +76,9 @@ extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), void objectiveFunction0(double *u, double *f, void *data) { - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[0] = u[0]; algebraic[1] = u[1]; @@ -83,9 +87,9 @@ void objectiveFunction0(double *u, double *f, void *data) f[1] = computedConstants[0]+3.0*algebraic[1]-algebraic[0]-19.0; } -void findRoot0(double *variables) +void findRoot0(double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { variables }; + RootFindingInfo rfi = { constants, computedConstants, algebraic }; double u[2]; u[0] = algebraic[0]; @@ -112,6 +116,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic) { - findRoot0(variables); + findRoot0(constants, computedConstants, algebraic); algebraic[2] = algebraic[1]+algebraic[0]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 7cc2478a0..780f9aac8 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -43,7 +43,9 @@ def create_algebraic_array(): def objective_function_0(u, f, data): - variables = data[0] + constants = data[0] + computed_constants = data[1] + algebraic = data[2] algebraic[0] = u[0] algebraic[1] = u[1] @@ -52,13 +54,13 @@ def objective_function_0(u, f, data): f[1] = computed_constants[0]+3.0*algebraic[1]-algebraic[0]-19.0 -def find_root_0(variables): +def find_root_0(constants, computed_constants, algebraic): u = [nan]*2 u[0] = algebraic[0] u[1] = algebraic[1] - u = nla_solve(objective_function_0, u, 2, [variables]) + u = nla_solve(objective_function_0, u, 2, [constants, computed_constants, algebraic]) algebraic[0] = u[0] algebraic[1] = u[1] @@ -76,5 +78,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic): - find_root_0(variables) + find_root_0(constants, computed_constants, algebraic) algebraic[2] = algebraic[1]+algebraic[0] diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 6b0819a99..95913f322 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -92,7 +92,9 @@ typedef struct { double voi; double *states; double *rates; - double *variables; + double *constants; + double *computedConstants; + double *algebraic; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -103,16 +105,18 @@ void objectiveFunction0(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[0] = u[0]; f[0] = constants[0]-(algebraic[0]+algebraic[1]); } -void findRoot0(double voi, double *states, double *rates, double *variables) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[0]; @@ -127,16 +131,18 @@ void objectiveFunction1(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[4] = u[0]; f[0] = algebraic[2]-(algebraic[3]+algebraic[4]); } -void findRoot1(double voi, double *states, double *rates, double *variables) +void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[4]; @@ -166,19 +172,19 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { algebraic[1] = states[1]+constants[1]; - findRoot0(voi, states, rates, variables); + findRoot0(voi, states, rates, constants, computedConstants, algebraic); rates[0] = algebraic[0]; algebraic[2] = states[0]/constants[2]; algebraic[3] = constants[3]*algebraic[1]; - findRoot1(voi, states, rates, variables); + findRoot1(voi, states, rates, constants, computedConstants, algebraic); rates[1] = algebraic[4]/constants[4]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { algebraic[1] = states[1]+constants[1]; - findRoot0(voi, states, rates, variables); + findRoot0(voi, states, rates, constants, computedConstants, algebraic); algebraic[2] = states[0]/constants[2]; algebraic[3] = constants[3]*algebraic[1]; - findRoot1(voi, states, rates, variables); + findRoot1(voi, states, rates, constants, computedConstants, algebraic); } diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index ef14cb9e3..f53382f0f 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -62,19 +62,21 @@ def objective_function_0(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[0] = u[0] f[0] = constants[0]-(algebraic[0]+algebraic[1]) -def find_root_0(voi, states, rates, variables): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[0] - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[0] = u[0] @@ -83,19 +85,21 @@ def objective_function_1(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[4] = u[0] f[0] = algebraic[2]-(algebraic[3]+algebraic[4]) -def find_root_1(voi, states, rates, variables): +def find_root_1(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[4] - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[4] = u[0] @@ -118,17 +122,17 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): algebraic[1] = states[1]+constants[1] - find_root_0(voi, states, rates, variables) + find_root_0(voi, states, rates, constants, computed_constants, algebraic) rates[0] = algebraic[0] algebraic[2] = states[0]/constants[2] algebraic[3] = constants[3]*algebraic[1] - find_root_1(voi, states, rates, variables) + find_root_1(voi, states, rates, constants, computed_constants, algebraic) rates[1] = algebraic[4]/constants[4] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): algebraic[1] = states[1]+constants[1] - find_root_0(voi, states, rates, variables) + find_root_0(voi, states, rates, constants, computed_constants, algebraic) algebraic[2] = states[0]/constants[2] algebraic[3] = constants[3]*algebraic[1] - find_root_1(voi, states, rates, variables) + find_root_1(voi, states, rates, constants, computed_constants, algebraic) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index a940fe5cf..256bce34c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -102,7 +102,9 @@ typedef struct { double voi; double *states; double *rates; - double *variables; + double *constants; + double *computedConstants; + double *algebraic; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -113,16 +115,18 @@ void objectiveFunction0(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[0] = u[0]; f[0] = algebraic[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; } -void findRoot0(double voi, double *states, double *rates, double *variables) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[0]; @@ -137,16 +141,18 @@ void objectiveFunction1(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; rates[0] = u[0]; f[0] = rates[0]-(-(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0])-0.0; } -void findRoot1(double voi, double *states, double *rates, double *variables) +void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = rates[0]; @@ -161,16 +167,18 @@ void objectiveFunction2(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[4] = u[0]; f[0] = algebraic[4]-(constants[1]-10.613)-0.0; } -void findRoot2(double voi, double *states, double *rates, double *variables) +void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[4]; @@ -185,16 +193,18 @@ void objectiveFunction3(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[1] = u[0]; f[0] = algebraic[1]-constants[2]*(states[0]-algebraic[4])-0.0; } -void findRoot3(double voi, double *states, double *rates, double *variables) +void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[1]; @@ -209,16 +219,18 @@ void objectiveFunction4(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[5] = u[0]; f[0] = algebraic[5]-(constants[1]-115.0)-0.0; } -void findRoot4(double voi, double *states, double *rates, double *variables) +void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[5]; @@ -233,16 +245,18 @@ void objectiveFunction5(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[3] = u[0]; f[0] = algebraic[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5])-0.0; } -void findRoot5(double voi, double *states, double *rates, double *variables) +void findRoot5(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[3]; @@ -257,16 +271,18 @@ void objectiveFunction6(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[6] = u[0]; f[0] = algebraic[6]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0; } -void findRoot6(double voi, double *states, double *rates, double *variables) +void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[6]; @@ -281,16 +297,18 @@ void objectiveFunction7(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[7] = u[0]; f[0] = algebraic[7]-4.0*exp(states[0]/18.0)-0.0; } -void findRoot7(double voi, double *states, double *rates, double *variables) +void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[7]; @@ -305,16 +323,18 @@ void objectiveFunction8(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; rates[2] = u[0]; f[0] = rates[2]-(algebraic[6]*(1.0-states[2])-algebraic[7]*states[2])-0.0; } -void findRoot8(double voi, double *states, double *rates, double *variables) +void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = rates[2]; @@ -329,16 +349,18 @@ void objectiveFunction9(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[8] = u[0]; f[0] = algebraic[8]-0.07*exp(states[0]/20.0)-0.0; } -void findRoot9(double voi, double *states, double *rates, double *variables) +void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[8]; @@ -353,16 +375,18 @@ void objectiveFunction10(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[9] = u[0]; f[0] = algebraic[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; } -void findRoot10(double voi, double *states, double *rates, double *variables) +void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[9]; @@ -377,16 +401,18 @@ void objectiveFunction11(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; rates[1] = u[0]; f[0] = rates[1]-(algebraic[8]*(1.0-states[1])-algebraic[9]*states[1])-0.0; } -void findRoot11(double voi, double *states, double *rates, double *variables) +void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = rates[1]; @@ -401,16 +427,18 @@ void objectiveFunction12(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[10] = u[0]; f[0] = algebraic[10]-(constants[1]+12.0)-0.0; } -void findRoot12(double voi, double *states, double *rates, double *variables) +void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[10]; @@ -425,16 +453,18 @@ void objectiveFunction13(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[2] = u[0]; f[0] = algebraic[2]-constants[4]*pow(states[3], 4.0)*(states[0]-algebraic[10])-0.0; } -void findRoot13(double voi, double *states, double *rates, double *variables) +void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[2]; @@ -449,16 +479,18 @@ void objectiveFunction14(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[11] = u[0]; f[0] = algebraic[11]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; } -void findRoot14(double voi, double *states, double *rates, double *variables) +void findRoot14(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[11]; @@ -473,16 +505,18 @@ void objectiveFunction15(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[12] = u[0]; f[0] = algebraic[12]-0.125*exp(states[0]/80.0)-0.0; } -void findRoot15(double voi, double *states, double *rates, double *variables) +void findRoot15(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[12]; @@ -497,16 +531,18 @@ void objectiveFunction16(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; rates[3] = u[0]; f[0] = rates[3]-(algebraic[11]*(1.0-states[3])-algebraic[12]*states[3])-0.0; } -void findRoot16(double voi, double *states, double *rates, double *variables) +void findRoot16(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = rates[3]; @@ -552,42 +588,42 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - findRoot0(voi, states, rates, variables); - findRoot2(voi, states, rates, variables); - findRoot3(voi, states, rates, variables); - findRoot14(voi, states, rates, variables); - findRoot15(voi, states, rates, variables); - findRoot16(voi, states, rates, variables); - findRoot12(voi, states, rates, variables); - findRoot13(voi, states, rates, variables); - findRoot9(voi, states, rates, variables); - findRoot10(voi, states, rates, variables); - findRoot11(voi, states, rates, variables); - findRoot6(voi, states, rates, variables); - findRoot7(voi, states, rates, variables); - findRoot8(voi, states, rates, variables); - findRoot4(voi, states, rates, variables); - findRoot5(voi, states, rates, variables); - findRoot1(voi, states, rates, variables); + findRoot0(voi, states, rates, constants, computedConstants, algebraic); + findRoot2(voi, states, rates, constants, computedConstants, algebraic); + findRoot3(voi, states, rates, constants, computedConstants, algebraic); + findRoot14(voi, states, rates, constants, computedConstants, algebraic); + findRoot15(voi, states, rates, constants, computedConstants, algebraic); + findRoot16(voi, states, rates, constants, computedConstants, algebraic); + findRoot12(voi, states, rates, constants, computedConstants, algebraic); + findRoot13(voi, states, rates, constants, computedConstants, algebraic); + findRoot9(voi, states, rates, constants, computedConstants, algebraic); + findRoot10(voi, states, rates, constants, computedConstants, algebraic); + findRoot11(voi, states, rates, constants, computedConstants, algebraic); + findRoot6(voi, states, rates, constants, computedConstants, algebraic); + findRoot7(voi, states, rates, constants, computedConstants, algebraic); + findRoot8(voi, states, rates, constants, computedConstants, algebraic); + findRoot4(voi, states, rates, constants, computedConstants, algebraic); + findRoot5(voi, states, rates, constants, computedConstants, algebraic); + findRoot1(voi, states, rates, constants, computedConstants, algebraic); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - findRoot0(voi, states, rates, variables); - findRoot2(voi, states, rates, variables); - findRoot3(voi, states, rates, variables); - findRoot14(voi, states, rates, variables); - findRoot15(voi, states, rates, variables); - findRoot16(voi, states, rates, variables); - findRoot12(voi, states, rates, variables); - findRoot13(voi, states, rates, variables); - findRoot9(voi, states, rates, variables); - findRoot10(voi, states, rates, variables); - findRoot11(voi, states, rates, variables); - findRoot6(voi, states, rates, variables); - findRoot7(voi, states, rates, variables); - findRoot8(voi, states, rates, variables); - findRoot4(voi, states, rates, variables); - findRoot5(voi, states, rates, variables); - findRoot1(voi, states, rates, variables); + findRoot0(voi, states, rates, constants, computedConstants, algebraic); + findRoot2(voi, states, rates, constants, computedConstants, algebraic); + findRoot3(voi, states, rates, constants, computedConstants, algebraic); + findRoot14(voi, states, rates, constants, computedConstants, algebraic); + findRoot15(voi, states, rates, constants, computedConstants, algebraic); + findRoot16(voi, states, rates, constants, computedConstants, algebraic); + findRoot12(voi, states, rates, constants, computedConstants, algebraic); + findRoot13(voi, states, rates, constants, computedConstants, algebraic); + findRoot9(voi, states, rates, constants, computedConstants, algebraic); + findRoot10(voi, states, rates, constants, computedConstants, algebraic); + findRoot11(voi, states, rates, constants, computedConstants, algebraic); + findRoot6(voi, states, rates, constants, computedConstants, algebraic); + findRoot7(voi, states, rates, constants, computedConstants, algebraic); + findRoot8(voi, states, rates, constants, computedConstants, algebraic); + findRoot4(voi, states, rates, constants, computedConstants, algebraic); + findRoot5(voi, states, rates, constants, computedConstants, algebraic); + findRoot1(voi, states, rates, constants, computedConstants, algebraic); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 9d57d7855..90843ccc6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -84,19 +84,21 @@ def objective_function_0(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[0] = u[0] f[0] = algebraic[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 -def find_root_0(voi, states, rates, variables): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[0] - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[0] = u[0] @@ -105,19 +107,21 @@ def objective_function_1(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] rates[0] = u[0] f[0] = rates[0]-(-(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0])-0.0 -def find_root_1(voi, states, rates, variables): +def find_root_1(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = rates[0] - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) rates[0] = u[0] @@ -126,19 +130,21 @@ def objective_function_2(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[4] = u[0] f[0] = algebraic[4]-(constants[1]-10.613)-0.0 -def find_root_2(voi, states, rates, variables): +def find_root_2(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[4] - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[4] = u[0] @@ -147,19 +153,21 @@ def objective_function_3(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[1] = u[0] f[0] = algebraic[1]-constants[2]*(states[0]-algebraic[4])-0.0 -def find_root_3(voi, states, rates, variables): +def find_root_3(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[1] - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[1] = u[0] @@ -168,19 +176,21 @@ def objective_function_4(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[5] = u[0] f[0] = algebraic[5]-(constants[1]-115.0)-0.0 -def find_root_4(voi, states, rates, variables): +def find_root_4(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[5] - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[5] = u[0] @@ -189,19 +199,21 @@ def objective_function_5(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[3] = u[0] f[0] = algebraic[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5])-0.0 -def find_root_5(voi, states, rates, variables): +def find_root_5(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[3] - u = nla_solve(objective_function_5, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_5, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[3] = u[0] @@ -210,19 +222,21 @@ def objective_function_6(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[6] = u[0] f[0] = algebraic[6]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0 -def find_root_6(voi, states, rates, variables): +def find_root_6(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[6] - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[6] = u[0] @@ -231,19 +245,21 @@ def objective_function_7(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[7] = u[0] f[0] = algebraic[7]-4.0*exp(states[0]/18.0)-0.0 -def find_root_7(voi, states, rates, variables): +def find_root_7(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[7] - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[7] = u[0] @@ -252,19 +268,21 @@ def objective_function_8(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] rates[2] = u[0] f[0] = rates[2]-(algebraic[6]*(1.0-states[2])-algebraic[7]*states[2])-0.0 -def find_root_8(voi, states, rates, variables): +def find_root_8(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = rates[2] - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) rates[2] = u[0] @@ -273,19 +291,21 @@ def objective_function_9(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[8] = u[0] f[0] = algebraic[8]-0.07*exp(states[0]/20.0)-0.0 -def find_root_9(voi, states, rates, variables): +def find_root_9(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[8] - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[8] = u[0] @@ -294,19 +314,21 @@ def objective_function_10(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[9] = u[0] f[0] = algebraic[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 -def find_root_10(voi, states, rates, variables): +def find_root_10(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[9] - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[9] = u[0] @@ -315,19 +337,21 @@ def objective_function_11(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] rates[1] = u[0] f[0] = rates[1]-(algebraic[8]*(1.0-states[1])-algebraic[9]*states[1])-0.0 -def find_root_11(voi, states, rates, variables): +def find_root_11(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = rates[1] - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) rates[1] = u[0] @@ -336,19 +360,21 @@ def objective_function_12(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[10] = u[0] f[0] = algebraic[10]-(constants[1]+12.0)-0.0 -def find_root_12(voi, states, rates, variables): +def find_root_12(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[10] - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[10] = u[0] @@ -357,19 +383,21 @@ def objective_function_13(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[2] = u[0] f[0] = algebraic[2]-constants[4]*pow(states[3], 4.0)*(states[0]-algebraic[10])-0.0 -def find_root_13(voi, states, rates, variables): +def find_root_13(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[2] - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[2] = u[0] @@ -378,19 +406,21 @@ def objective_function_14(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[11] = u[0] f[0] = algebraic[11]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 -def find_root_14(voi, states, rates, variables): +def find_root_14(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[11] - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[11] = u[0] @@ -399,19 +429,21 @@ def objective_function_15(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[12] = u[0] f[0] = algebraic[12]-0.125*exp(states[0]/80.0)-0.0 -def find_root_15(voi, states, rates, variables): +def find_root_15(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[12] - u = nla_solve(objective_function_15, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_15, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[12] = u[0] @@ -420,19 +452,21 @@ def objective_function_16(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] rates[3] = u[0] f[0] = rates[3]-(algebraic[11]*(1.0-states[3])-algebraic[12]*states[3])-0.0 -def find_root_16(voi, states, rates, variables): +def find_root_16(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = rates[3] - u = nla_solve(objective_function_16, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_16, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) rates[3] = u[0] @@ -471,40 +505,40 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - find_root_0(voi, states, rates, variables) - find_root_2(voi, states, rates, variables) - find_root_3(voi, states, rates, variables) - find_root_14(voi, states, rates, variables) - find_root_15(voi, states, rates, variables) - find_root_16(voi, states, rates, variables) - find_root_12(voi, states, rates, variables) - find_root_13(voi, states, rates, variables) - find_root_9(voi, states, rates, variables) - find_root_10(voi, states, rates, variables) - find_root_11(voi, states, rates, variables) - find_root_6(voi, states, rates, variables) - find_root_7(voi, states, rates, variables) - find_root_8(voi, states, rates, variables) - find_root_4(voi, states, rates, variables) - find_root_5(voi, states, rates, variables) - find_root_1(voi, states, rates, variables) + find_root_0(voi, states, rates, constants, computed_constants, algebraic) + find_root_2(voi, states, rates, constants, computed_constants, algebraic) + find_root_3(voi, states, rates, constants, computed_constants, algebraic) + find_root_14(voi, states, rates, constants, computed_constants, algebraic) + find_root_15(voi, states, rates, constants, computed_constants, algebraic) + find_root_16(voi, states, rates, constants, computed_constants, algebraic) + find_root_12(voi, states, rates, constants, computed_constants, algebraic) + find_root_13(voi, states, rates, constants, computed_constants, algebraic) + find_root_9(voi, states, rates, constants, computed_constants, algebraic) + find_root_10(voi, states, rates, constants, computed_constants, algebraic) + find_root_11(voi, states, rates, constants, computed_constants, algebraic) + find_root_6(voi, states, rates, constants, computed_constants, algebraic) + find_root_7(voi, states, rates, constants, computed_constants, algebraic) + find_root_8(voi, states, rates, constants, computed_constants, algebraic) + find_root_4(voi, states, rates, constants, computed_constants, algebraic) + find_root_5(voi, states, rates, constants, computed_constants, algebraic) + find_root_1(voi, states, rates, constants, computed_constants, algebraic) def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - find_root_0(voi, states, rates, variables) - find_root_2(voi, states, rates, variables) - find_root_3(voi, states, rates, variables) - find_root_14(voi, states, rates, variables) - find_root_15(voi, states, rates, variables) - find_root_16(voi, states, rates, variables) - find_root_12(voi, states, rates, variables) - find_root_13(voi, states, rates, variables) - find_root_9(voi, states, rates, variables) - find_root_10(voi, states, rates, variables) - find_root_11(voi, states, rates, variables) - find_root_6(voi, states, rates, variables) - find_root_7(voi, states, rates, variables) - find_root_8(voi, states, rates, variables) - find_root_4(voi, states, rates, variables) - find_root_5(voi, states, rates, variables) - find_root_1(voi, states, rates, variables) + find_root_0(voi, states, rates, constants, computed_constants, algebraic) + find_root_2(voi, states, rates, constants, computed_constants, algebraic) + find_root_3(voi, states, rates, constants, computed_constants, algebraic) + find_root_14(voi, states, rates, constants, computed_constants, algebraic) + find_root_15(voi, states, rates, constants, computed_constants, algebraic) + find_root_16(voi, states, rates, constants, computed_constants, algebraic) + find_root_12(voi, states, rates, constants, computed_constants, algebraic) + find_root_13(voi, states, rates, constants, computed_constants, algebraic) + find_root_9(voi, states, rates, constants, computed_constants, algebraic) + find_root_10(voi, states, rates, constants, computed_constants, algebraic) + find_root_11(voi, states, rates, constants, computed_constants, algebraic) + find_root_6(voi, states, rates, constants, computed_constants, algebraic) + find_root_7(voi, states, rates, constants, computed_constants, algebraic) + find_root_8(voi, states, rates, constants, computed_constants, algebraic) + find_root_4(voi, states, rates, constants, computed_constants, algebraic) + find_root_5(voi, states, rates, constants, computed_constants, algebraic) + find_root_1(voi, states, rates, constants, computed_constants, algebraic) diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 9f90b3f9c..0983133e1 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -87,7 +87,9 @@ typedef struct { double voi; double *states; double *rates; - double *variables; + double *constants; + double *computedConstants; + double *algebraic; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -98,16 +100,18 @@ void objectiveFunction0(double *u, double *f, void *data) double voi = ((RootFindingInfo *) data)->voi; double *states = ((RootFindingInfo *) data)->states; double *rates = ((RootFindingInfo *) data)->rates; - double *variables = ((RootFindingInfo *) data)->variables; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; algebraic[0] = u[0]; f[0] = 1.0-(states[0]+states[1]+algebraic[0]); } -void findRoot0(double voi, double *states, double *rates, double *variables) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - RootFindingInfo rfi = { voi, states, rates, variables }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; u[0] = algebraic[0]; @@ -133,13 +137,13 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - findRoot0(voi, states, rates, variables); + findRoot0(voi, states, rates, constants, computedConstants, algebraic); rates[0] = -constants[0]*states[0]+constants[1]*states[1]*algebraic[0]; rates[1] = constants[0]*states[0]-constants[2]*pow(states[1], 2.0)-constants[1]*states[1]*algebraic[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - findRoot0(voi, states, rates, variables); + findRoot0(voi, states, rates, constants, computedConstants, algebraic); algebraic[1] = 10000.0*states[1]; } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 512fd8d9f..1bb4bf2b0 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -57,19 +57,21 @@ def objective_function_0(u, f, data): voi = data[0] states = data[1] rates = data[2] - variables = data[3] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] algebraic[0] = u[0] f[0] = 1.0-(states[0]+states[1]+algebraic[0]) -def find_root_0(voi, states, rates, variables): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 u[0] = algebraic[0] - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, variables]) + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) algebraic[0] = u[0] @@ -88,11 +90,11 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - find_root_0(voi, states, rates, variables) + find_root_0(voi, states, rates, constants, computed_constants, algebraic) rates[0] = -constants[0]*states[0]+constants[1]*states[1]*algebraic[0] rates[1] = constants[0]*states[0]-constants[2]*pow(states[1], 2.0)-constants[1]*states[1]*algebraic[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - find_root_0(voi, states, rates, variables) + find_root_0(voi, states, rates, constants, computed_constants, algebraic) algebraic[1] = 10000.0*states[1] From d16520832d4ae50ec6e27bb5b80bc5032044025a Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 19 Aug 2024 22:53:28 +0200 Subject: [PATCH 43/74] GeneratorProfile: use the constants, computed constants, and algebraic arrays rather than the variables array to compute external variables. --- src/generatorprofile.cpp | 12 ++++++------ src/generatorprofilesha1values.h | 4 ++-- tests/bindings/python/test_generator_profile.py | 8 ++++---- tests/generator/generatorprofile.cpp | 8 ++++---- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.external.c | 6 +++--- .../model.external.h | 2 +- .../model.external.py | 6 +++--- .../generator/cell_geometry_model/model.external.c | 4 ++-- .../generator/cell_geometry_model/model.external.h | 2 +- .../generator/cell_geometry_model/model.external.py | 4 ++-- .../model.algebraic.c | 4 ++-- .../model.algebraic.h | 2 +- .../model.algebraic.py | 4 ++-- .../model.computed.constant.c | 4 ++-- .../model.computed.constant.h | 2 +- .../model.computed.constant.py | 4 ++-- .../model.constant.c | 4 ++-- .../model.constant.h | 2 +- .../model.constant.py | 4 ++-- .../model.dependent.algebraic.c | 8 ++++---- .../model.dependent.algebraic.h | 2 +- .../model.dependent.algebraic.py | 8 ++++---- .../model.dependent.computed.constant.c | 8 ++++---- .../model.dependent.computed.constant.h | 2 +- .../model.dependent.computed.constant.py | 8 ++++---- .../model.dependent.constant.c | 8 ++++---- .../model.dependent.constant.h | 2 +- .../model.dependent.constant.py | 8 ++++---- .../model.dependent.state.c | 6 +++--- .../model.dependent.state.h | 2 +- .../model.dependent.state.py | 6 +++--- .../model.external.c | 10 +++++----- .../model.external.h | 2 +- .../model.external.py | 10 +++++----- .../model.state.c | 4 ++-- .../model.state.h | 2 +- .../model.state.py | 4 ++-- .../unknown_variable_as_external_variable/model.c | 2 +- .../unknown_variable_as_external_variable/model.h | 2 +- .../unknown_variable_as_external_variable/model.py | 2 +- 46 files changed, 102 insertions(+), 102 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index db36f888c..6c51b0242 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -290,11 +290,11 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mAlgebraicArrayString = "algebraic"; mExternalArrayString = "externals"; - mExternalVariableMethodTypeDefinitionFamString = "typedef double (* ExternalVariable)(double *variables, size_t index);\n"; - mExternalVariableMethodTypeDefinitionFdmString = "typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index);\n"; + mExternalVariableMethodTypeDefinitionFamString = "typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index);\n"; + mExternalVariableMethodTypeDefinitionFdmString = "typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index);\n"; - mExternalVariableMethodCallFamString = "externalVariable(variables, [INDEX])"; - mExternalVariableMethodCallFdmString = "externalVariable(voi, states, rates, variables, [INDEX])"; + mExternalVariableMethodCallFamString = "externalVariable(constants, computedConstants, algebraic, [INDEX])"; + mExternalVariableMethodCallFdmString = "externalVariable(voi, states, rates, constants, computedConstants, algebraic, [INDEX])"; mRootFindingInfoObjectFamString = "typedef struct {\n" " double *constants;\n" @@ -742,8 +742,8 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mExternalVariableMethodTypeDefinitionFamString = ""; mExternalVariableMethodTypeDefinitionFdmString = ""; - mExternalVariableMethodCallFamString = "external_variable(variables, [INDEX])"; - mExternalVariableMethodCallFdmString = "external_variable(voi, states, rates, variables, [INDEX])"; + mExternalVariableMethodCallFamString = "external_variable(constants, computed_constants, algebraic, [INDEX])"; + mExternalVariableMethodCallFdmString = "external_variable(voi, states, rates, constants, computed_constants, algebraic, [INDEX])"; mRootFindingInfoObjectFamString = ""; mRootFindingInfoObjectFdmString = ""; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index fb447d903..e4bf327ed 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "d89b171278ed3bf717a6127eeb6ac6a7a90d0157"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "b5d9c5ac70bf89bf6396b8928885781b96e458ba"; +static const char C_GENERATOR_PROFILE_SHA1[] = "1e07f5b270d8f8fe62cffa8bcd81bf04804aa9e5"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "3c4d4503bca8066e85c60491ac85a960ec8144bf"; } // namespace libcellml diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 32b35283a..5ec63521c 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -1677,13 +1677,13 @@ def test_external_variable_method_type_definition_string(self): g = GeneratorProfile() self.assertEqual( - 'typedef double (* ExternalVariable)(double *variables, size_t index);\n', + 'typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index);\n', g.externalVariableMethodTypeDefinitionString(False)) g.setExternalVariableMethodTypeDefinitionString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodTypeDefinitionString(False)) self.assertEqual( - 'typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index);\n', + 'typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index);\n', g.externalVariableMethodTypeDefinitionString(True)) g.setExternalVariableMethodTypeDefinitionString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodTypeDefinitionString(True)) @@ -1693,12 +1693,12 @@ def test_external_variable_method_call_string(self): g = GeneratorProfile() - self.assertEqual('externalVariable(variables, [INDEX])', + self.assertEqual('externalVariable(constants, computedConstants, algebraic, [INDEX])', g.externalVariableMethodCallString(False)) g.setExternalVariableMethodCallString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodCallString(False)) - self.assertEqual('externalVariable(voi, states, rates, variables, [INDEX])', + self.assertEqual('externalVariable(voi, states, rates, constants, computedConstants, algebraic, [INDEX])', g.externalVariableMethodCallString(True)) g.setExternalVariableMethodCallString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodCallString(True)) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 4cc9c6412..c95a5112a 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -342,11 +342,11 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("algebraic", generatorProfile->algebraicArrayString()); EXPECT_EQ("externals", generatorProfile->externalArrayString()); - EXPECT_EQ("typedef double (* ExternalVariable)(double *variables, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(false)); - EXPECT_EQ("typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(true)); + EXPECT_EQ("typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(false)); + EXPECT_EQ("typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(true)); - EXPECT_EQ("externalVariable(variables, [INDEX])", generatorProfile->externalVariableMethodCallString(false)); - EXPECT_EQ("externalVariable(voi, states, rates, variables, [INDEX])", generatorProfile->externalVariableMethodCallString(true)); + EXPECT_EQ("externalVariable(constants, computedConstants, algebraic, [INDEX])", generatorProfile->externalVariableMethodCallString(false)); + EXPECT_EQ("externalVariable(voi, states, rates, constants, computedConstants, algebraic, [INDEX])", generatorProfile->externalVariableMethodCallString(true)); EXPECT_EQ("typedef struct {\n" " double *constants;\n" diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 70e5a39b8..6e39ffddf 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -86,6 +86,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[0] = externalVariable(variables, 0); + externals[0] = externalVariable(constants, computedConstants, algebraic, 0); algebraic[0] = externals[0]; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index 949208875..c68c54a28 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -30,7 +30,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *variables, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 244859d72..953b054c8 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -52,5 +52,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(variables, 0) + externals[0] = external_variable(constants, computed_constants, algebraic, 0) algebraic[0] = externals[0] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index 43fe422a9..dd58522e6 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -91,5 +91,5 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[0] = externalVariable(variables, 0); + externals[0] = externalVariable(constants, computedConstants, algebraic, 0); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index 949208875..c68c54a28 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -30,7 +30,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *variables, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index c5a93e2ac..8be4ddcd1 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -56,4 +56,4 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(variables, 0) + externals[0] = external_variable(constants, computed_constants, algebraic, 0) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c index 38c67fb56..ee21f220e 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c @@ -87,7 +87,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[0] = externalVariable(variables, 0); - externals[1] = externalVariable(variables, 1); - externals[2] = externalVariable(variables, 2); + externals[0] = externalVariable(constants, computedConstants, algebraic, 0); + externals[1] = externalVariable(constants, computedConstants, algebraic, 1); + externals[2] = externalVariable(constants, computedConstants, algebraic, 2); } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h index 33b790575..8ea01811f 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h @@ -30,7 +30,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *variables, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py index 7d519d04b..65c6876d4 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py @@ -53,6 +53,6 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(variables, 0) - externals[1] = external_variable(variables, 1) - externals[2] = external_variable(variables, 2) + externals[0] = external_variable(constants, computed_constants, algebraic, 0) + externals[1] = external_variable(constants, computed_constants, algebraic, 1) + externals[2] = external_variable(constants, computed_constants, algebraic, 2) diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 1b946f417..de3a3ab80 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -88,8 +88,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[0] = externalVariable(variables, 0); - externals[1] = externalVariable(variables, 1); + externals[0] = externalVariable(constants, computedConstants, algebraic, 0); + externals[1] = externalVariable(constants, computedConstants, algebraic, 1); algebraic[0] = 1000.0*3.14*externals[1]*externals[1]*externals[0]; algebraic[1] = 0.02*algebraic[0]; } diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 28c04e714..c312a35c7 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -30,7 +30,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *variables, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 463fb5960..c45a649c6 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -54,7 +54,7 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(variables, 0) - externals[1] = external_variable(variables, 1) + externals[0] = external_variable(constants, computed_constants, algebraic, 0) + externals[1] = external_variable(constants, computed_constants, algebraic, 1) algebraic[0] = 1000.0*3.14*externals[1]*externals[1]*externals[0] algebraic[1] = 0.02*algebraic[0] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 3a449edd1..20a0c70ea 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -135,7 +135,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); @@ -153,7 +153,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index 1ba9603cc..35a6bd9c3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -34,7 +34,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 7e9218d84..35757ff10 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -104,7 +104,7 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) @@ -121,7 +121,7 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index abf11523e..223249ed9 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -135,7 +135,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[1] = constants[2]*(states[0]-externals[0]); algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); @@ -153,7 +153,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[1] = constants[2]*(states[0]-externals[0]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index 1ba9603cc..35a6bd9c3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -34,7 +34,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 66a555dfb..c00871301 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -104,7 +104,7 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[1] = constants[2]*(states[0]-externals[0]) algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) @@ -121,7 +121,7 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[1] = constants[2]*(states[0]-externals[0]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 0b61cfd4b..708762d5a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -135,7 +135,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); @@ -162,5 +162,5 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(states[0]/80.0); - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index 1ba9603cc..35a6bd9c3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -34,7 +34,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 30ac1e478..47529b9f1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -104,7 +104,7 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) @@ -130,4 +130,4 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(states[0]/80.0) - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 174c5d1c5..37c38f09a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -135,8 +135,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, variables, 1); - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); @@ -153,8 +153,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, variables, 1); - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index 1ba9603cc..35a6bd9c3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -34,7 +34,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index db89293eb..dcce03903 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -104,8 +104,8 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[1] = external_variable(voi, states, rates, variables, 1) - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) @@ -121,8 +121,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[1] = external_variable(voi, states, rates, variables, 1) - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 9e73eb2cb..b52e837c2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -132,8 +132,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[1] = externalVariable(voi, states, rates, variables, 1); - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[4] = externals[0]-10.613; algebraic[1] = constants[1]*(states[0]-algebraic[4]); algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]); @@ -153,8 +153,8 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, variables, 1); - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[4] = externals[0]-10.613; algebraic[1] = constants[1]*(states[0]-algebraic[4]); algebraic[5] = externals[0]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index 1ba9603cc..35a6bd9c3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -34,7 +34,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 42ab91f87..87f39ea1b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -102,8 +102,8 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[1] = external_variable(voi, states, rates, variables, 1) - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[4] = externals[0]-10.613 algebraic[1] = constants[1]*(states[0]-algebraic[4]) algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]) @@ -122,8 +122,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[1] = external_variable(voi, states, rates, variables, 1) - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[4] = externals[0]-10.613 algebraic[1] = constants[1]*(states[0]-algebraic[4]) algebraic[5] = externals[0]-115.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 8c7192206..a1c9778c8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -134,8 +134,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[1] = externalVariable(voi, states, rates, variables, 1); - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); @@ -154,7 +154,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = constants[1]*(states[0]-computedConstants[0]); - externals[1] = externalVariable(voi, states, rates, variables, 1); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); @@ -163,5 +163,5 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(states[0]/80.0); - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index 1ba9603cc..35a6bd9c3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -34,7 +34,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 88ab261a3..e72a244f0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -103,8 +103,8 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[1] = external_variable(voi, states, rates, variables, 1) - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) @@ -122,7 +122,7 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[1] = constants[1]*(states[0]-computed_constants[0]) - externals[1] = external_variable(voi, states, rates, variables, 1) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) @@ -131,4 +131,4 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(states[0]/80.0) - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index b41fa29b6..7c679fed8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -133,7 +133,7 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[6] = 0.07*exp(externals[0]/20.0); algebraic[7] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0); rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0]; @@ -145,9 +145,9 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[1] = constants[2]*(externals[0]-computedConstants[0]); - externals[1] = externalVariable(voi, states, rates, variables, 1); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); algebraic[3] = constants[3]*pow(externals[1], 3.0)*states[0]*(externals[0]-computedConstants[1]); algebraic[4] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(externals[0]/18.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index 1ba9603cc..35a6bd9c3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -34,7 +34,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 47adbb19b..d1dcd1929 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -102,7 +102,7 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[6] = 0.07*exp(externals[0]/20.0) algebraic[7] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0) rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0] @@ -113,9 +113,9 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[1] = constants[2]*(externals[0]-computed_constants[0]) - externals[1] = external_variable(voi, states, rates, variables, 1) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) algebraic[3] = constants[3]*pow(externals[1], 3.0)*states[0]*(externals[0]-computed_constants[1]) algebraic[4] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(externals[0]/18.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index a57d9f040..f1285c30d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -134,14 +134,14 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[3] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0); algebraic[4] = 4.0*exp(externals[0]/18.0); rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1]; algebraic[5] = 0.07*exp(externals[0]/20.0); algebraic[6] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0); rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0]; - externals[2] = externalVariable(voi, states, rates, variables, 2); + externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 2); algebraic[7] = 0.125*exp(externals[0]/80.0); rates[2] = externals[2]*(1.0-states[2])-algebraic[7]*states[2]; } @@ -149,9 +149,9 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[1] = constants[2]*(externals[0]-computedConstants[0]); - externals[2] = externalVariable(voi, states, rates, variables, 2); - externals[1] = externalVariable(voi, states, rates, variables, 1); + externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 2); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[0]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index 1ba9603cc..35a6bd9c3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -34,7 +34,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 2f58c315a..b726fdfa0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -103,22 +103,22 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[3] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0) algebraic[4] = 4.0*exp(externals[0]/18.0) rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1] algebraic[5] = 0.07*exp(externals[0]/20.0) algebraic[6] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0) rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0] - externals[2] = external_variable(voi, states, rates, variables, 2) + externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 2) algebraic[7] = 0.125*exp(externals[0]/80.0) rates[2] = externals[2]*(1.0-states[2])-algebraic[7]*states[2] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[1] = constants[2]*(externals[0]-computed_constants[0]) - externals[2] = external_variable(voi, states, rates, variables, 2) - externals[1] = external_variable(voi, states, rates, variables, 1) + externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 2) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[0]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 7ea8984c3..d6aed64a5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -137,7 +137,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraic[1] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; algebraic[6] = 0.07*exp(states[0]/20.0); @@ -151,7 +151,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - externals[0] = externalVariable(voi, states, rates, variables, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index 1ba9603cc..35a6bd9c3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -34,7 +34,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *variables, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 5963bee10..5ce36e54a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -106,7 +106,7 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic[1] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] algebraic[6] = 0.07*exp(states[0]/20.0) @@ -119,7 +119,7 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - externals[0] = external_variable(voi, states, rates, variables, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 4ba572946..439e1bb42 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -102,6 +102,6 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) { - externals[0] = externalVariable(variables, 0); + externals[0] = externalVariable(constants, computedConstants, algebraic, 0); algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+externals[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]); } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index c4d3c4020..49b5d66b7 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -30,7 +30,7 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *variables, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index); void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index bdd145f68..399e6d5bb 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -67,5 +67,5 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(variables, 0) + externals[0] = external_variable(constants, computed_constants, algebraic, 0) algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+externals[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) From 183d531e76c88fc69450dc540712891d53ce5791 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 20 Aug 2024 10:09:44 +0200 Subject: [PATCH 44/74] Tests: some minor cleaning up. --- tests/generator/generator.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index 52ccea486..1808a8d52 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -1514,12 +1514,12 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithAlgebraicVariablesAsExternalV auto analyser = libcellml::Analyser::create(); auto potassium_channel_n_gate_beta_n = model->component("potassium_channel_n_gate")->variable("beta_n"); - auto membrane_i_Stime = libcellml::AnalyserExternalVariable::create(model->component("membrane")->variable("i_Stim")); + auto membrane_i_Stim = libcellml::AnalyserExternalVariable::create(model->component("membrane")->variable("i_Stim")); - membrane_i_Stime->addDependency(potassium_channel_n_gate_beta_n); + membrane_i_Stim->addDependency(potassium_channel_n_gate_beta_n); analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(potassium_channel_n_gate_beta_n)); - analyser->addExternalVariable(membrane_i_Stime); + analyser->addExternalVariable(membrane_i_Stim); analyser->analyseModel(model); From 54e667365d4e663ec3466f62bcb3a1f3549c4da8 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 21 Aug 2024 21:30:03 +0200 Subject: [PATCH 45/74] Some minor cleaning up. --- src/analyser.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index 2f1359eee..519f9c9df 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -2782,13 +2782,11 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // in the API. std::map aie2aeMappings; - std::map v2aeMappings; for (const auto &internalEquation : mInternalEquations) { auto equation = AnalyserEquation::AnalyserEquationImpl::create(); aie2aeMappings.emplace(internalEquation, equation); - v2aeMappings.emplace(internalEquation->mUnknownVariables.front()->mVariable, equation); } // Start making our internal equations available through our API. From 62dc092a4d9f653a60a2093117dbc6449c19c4b1 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 20 Aug 2024 09:01:48 +0200 Subject: [PATCH 46/74] GeneratorProfile: use the externals array to retrieve the value of external variables. --- src/api/libcellml/generatorprofile.h | 8 +- src/generator.cpp | 4 +- src/generatorprofile.cpp | 113 ++++++++++++------ src/generatorprofile_p.h | 8 +- src/generatorprofilesha1values.h | 4 +- src/generatorprofiletools.cpp | 6 +- .../javascript/generatorprofile.test.js | 14 ++- .../bindings/python/test_generator_profile.py | 40 ++++--- tests/generator/generatorprofile.cpp | 53 +++++--- .../model.external.c | 4 +- .../model.external.h | 4 +- .../model.external.py | 4 +- .../model.external.c | 4 +- .../model.external.h | 4 +- .../model.external.py | 4 +- .../model.external.c | 8 +- .../model.external.h | 4 +- .../model.external.py | 8 +- .../cell_geometry_model/model.external.c | 6 +- .../cell_geometry_model/model.external.h | 4 +- .../cell_geometry_model/model.external.py | 6 +- .../model.algebraic.c | 8 +- .../model.algebraic.h | 6 +- .../model.algebraic.py | 8 +- .../model.computed.constant.c | 8 +- .../model.computed.constant.h | 6 +- .../model.computed.constant.py | 8 +- .../model.constant.c | 8 +- .../model.constant.h | 6 +- .../model.constant.py | 8 +- .../model.dependent.algebraic.c | 12 +- .../model.dependent.algebraic.h | 6 +- .../model.dependent.algebraic.py | 12 +- .../model.dependent.computed.constant.c | 12 +- .../model.dependent.computed.constant.h | 6 +- .../model.dependent.computed.constant.py | 12 +- .../model.dependent.constant.c | 12 +- .../model.dependent.constant.h | 6 +- .../model.dependent.constant.py | 12 +- .../model.dependent.state.c | 10 +- .../model.dependent.state.h | 6 +- .../model.dependent.state.py | 10 +- .../model.external.c | 14 +-- .../model.external.h | 6 +- .../model.external.py | 14 +-- .../model.state.c | 8 +- .../model.state.h | 6 +- .../model.state.py | 8 +- .../model.c | 4 +- .../model.h | 4 +- .../model.py | 4 +- 51 files changed, 323 insertions(+), 237 deletions(-) diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index 33b889c11..12e14cc26 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -3212,11 +3212,14 @@ class LIBCELLML_EXPORT GeneratorProfile * @param forDifferentialModel Whether the call to the root finding * information object is for a differential model, as opposed to an * algebraic model. + * @param withExternalVariables Whether the call to the root finding + * information object is for a model with external variables. * * @return The @c std::string for the data structure for the root finding * information object. */ - std::string rootFindingInfoObjectString(bool forDifferentialModel) const; + std::string rootFindingInfoObjectString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the data structure for the root finding @@ -3228,10 +3231,13 @@ class LIBCELLML_EXPORT GeneratorProfile * @param forDifferentialModel Whether the call to the root finding * information object is for a differential model, as opposed to an * algebraic model. + * @param withExternalVariables Whether the call to the root finding + * information object is for a model with external variables. * @param rootFindingInfoObjectString The @c std::string to use for the data * structure for the root finding information object. */ void setRootFindingInfoObjectString(bool forDifferentialModel, + bool withExternalVariables, const std::string &rootFindingInfoObjectString); /** diff --git a/src/generator.cpp b/src/generator.cpp index 9def5a35f..7f5a6261d 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -727,9 +727,9 @@ void Generator::GeneratorImpl::addExternalVariableMethodTypeDefinitionCode() void Generator::GeneratorImpl::addRootFindingInfoObjectCode() { if (modelHasNlas() - && !mProfile->rootFindingInfoObjectString(modelHasOdes()).empty()) { + && !mProfile->rootFindingInfoObjectString(modelHasOdes(), mModel->hasExternalVariables()).empty()) { mCode += newLineIfNeeded() - + mProfile->rootFindingInfoObjectString(modelHasOdes()); + + mProfile->rootFindingInfoObjectString(modelHasOdes(), mModel->hasExternalVariables()); } } diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 6c51b0242..b388edeeb 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -290,25 +290,42 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mAlgebraicArrayString = "algebraic"; mExternalArrayString = "externals"; - mExternalVariableMethodTypeDefinitionFamString = "typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index);\n"; - mExternalVariableMethodTypeDefinitionFdmString = "typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index);\n"; - - mExternalVariableMethodCallFamString = "externalVariable(constants, computedConstants, algebraic, [INDEX])"; - mExternalVariableMethodCallFdmString = "externalVariable(voi, states, rates, constants, computedConstants, algebraic, [INDEX])"; - - mRootFindingInfoObjectFamString = "typedef struct {\n" - " double *constants;\n" - " double *computedConstants;\n" - " double *algebraic;\n" - "} RootFindingInfo;\n"; - mRootFindingInfoObjectFdmString = "typedef struct {\n" - " double voi;\n" - " double *states;\n" - " double *rates;\n" - " double *constants;\n" - " double *computedConstants;\n" - " double *algebraic;\n" - "} RootFindingInfo;\n"; + mExternalVariableMethodTypeDefinitionFamString = "typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n"; + mExternalVariableMethodTypeDefinitionFdmString = "typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n"; + + mExternalVariableMethodCallFamString = "externalVariable(constants, computedConstants, algebraic, externals, [INDEX])"; + mExternalVariableMethodCallFdmString = "externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, [INDEX])"; + + mRootFindingInfoObjectFamWoevString = "typedef struct {\n" + " double *constants;\n" + " double *computedConstants;\n" + " double *algebraic;\n" + "} RootFindingInfo;\n"; + mRootFindingInfoObjectFamWevString = "typedef struct {\n" + " double *constants;\n" + " double *computedConstants;\n" + " double *algebraic;\n" + " double *externals;\n" + "} RootFindingInfo;\n"; + + mRootFindingInfoObjectFdmWoevString = "typedef struct {\n" + " double voi;\n" + " double *states;\n" + " double *rates;\n" + " double *constants;\n" + " double *computedConstants;\n" + " double *algebraic;\n" + "} RootFindingInfo;\n"; + mRootFindingInfoObjectFdmWevString = "typedef struct {\n" + " double voi;\n" + " double *states;\n" + " double *rates;\n" + " double *constants;\n" + " double *computedConstants;\n" + " double *algebraic;\n" + " double *externals;\n" + "} RootFindingInfo;\n"; + mExternNlaSolveMethodString = "extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *),\n" " double *u, size_t n, void *data);\n"; mFindRootCallFamString = "findRoot[INDEX](constants, computedConstants, algebraic);\n"; @@ -440,8 +457,8 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "}\n"; - mInterfaceComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n"; - mImplementationComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n{\n" + mInterfaceComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n"; + mImplementationComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n{\n" "[CODE]" "}\n"; @@ -451,8 +468,8 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "}\n"; - mInterfaceComputeVariablesMethodFamWevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n"; - mImplementationComputeVariablesMethodFamWevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n" + mInterfaceComputeVariablesMethodFamWevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n"; + mImplementationComputeVariablesMethodFamWevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n"; @@ -463,8 +480,8 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "}\n"; - mInterfaceComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n"; - mImplementationComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n" + mInterfaceComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n"; + mImplementationComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n"; @@ -742,11 +759,15 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mExternalVariableMethodTypeDefinitionFamString = ""; mExternalVariableMethodTypeDefinitionFdmString = ""; - mExternalVariableMethodCallFamString = "external_variable(constants, computed_constants, algebraic, [INDEX])"; - mExternalVariableMethodCallFdmString = "external_variable(voi, states, rates, constants, computed_constants, algebraic, [INDEX])"; + mExternalVariableMethodCallFamString = "external_variable(constants, computed_constants, algebraic, externals, [INDEX])"; + mExternalVariableMethodCallFdmString = "external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, [INDEX])"; + + mRootFindingInfoObjectFamWoevString = ""; + mRootFindingInfoObjectFamWevString = ""; + + mRootFindingInfoObjectFdmWoevString = ""; + mRootFindingInfoObjectFdmWevString = ""; - mRootFindingInfoObjectFamString = ""; - mRootFindingInfoObjectFdmString = ""; mExternNlaSolveMethodString = "\n" "from nlasolver import nla_solve" "\n"; @@ -834,7 +855,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceComputeRatesMethodWevString = ""; mImplementationComputeRatesMethodWevString = "\n" - "def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable):\n" + "def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable):\n" "[CODE]"; mInterfaceComputeVariablesMethodFamWoevString = ""; @@ -844,7 +865,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceComputeVariablesMethodFamWevString = ""; mImplementationComputeVariablesMethodFamWevString = "\n" - "def compute_variables(constants, computed_constants, algebraic, external_variable):\n" + "def compute_variables(constants, computed_constants, algebraic, externals, external_variable):\n" "[CODE]"; mInterfaceComputeVariablesMethodFdmWoevString = ""; @@ -854,7 +875,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceComputeVariablesMethodFdmWevString = ""; mImplementationComputeVariablesMethodFdmWevString = "\n" - "def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable):\n" + "def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable):\n" "[CODE]"; mEmptyMethodString = "pass\n"; @@ -2328,22 +2349,40 @@ void GeneratorProfile::setExternalVariableMethodCallString(bool forDifferentialM } } -std::string GeneratorProfile::rootFindingInfoObjectString(bool forDifferentialModel) const +std::string GeneratorProfile::rootFindingInfoObjectString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { - return mPimpl->mRootFindingInfoObjectFdmString; + if (withExternalVariables) { + return mPimpl->mRootFindingInfoObjectFdmWevString; + } + + return mPimpl->mRootFindingInfoObjectFdmWoevString; } - return mPimpl->mRootFindingInfoObjectFamString; + if (withExternalVariables) { + return mPimpl->mRootFindingInfoObjectFamWevString; + } + + return mPimpl->mRootFindingInfoObjectFamWoevString; } void GeneratorProfile::setRootFindingInfoObjectString(bool forDifferentialModel, + bool withExternalVariables, const std::string &rootFindingInfoObjectString) { if (forDifferentialModel) { - mPimpl->mRootFindingInfoObjectFdmString = rootFindingInfoObjectString; + if (withExternalVariables) { + mPimpl->mRootFindingInfoObjectFdmWevString = rootFindingInfoObjectString; + } else { + mPimpl->mRootFindingInfoObjectFdmWoevString = rootFindingInfoObjectString; + } } else { - mPimpl->mRootFindingInfoObjectFamString = rootFindingInfoObjectString; + if (withExternalVariables) { + mPimpl->mRootFindingInfoObjectFamWevString = rootFindingInfoObjectString; + } else { + mPimpl->mRootFindingInfoObjectFamWoevString = rootFindingInfoObjectString; + } } } diff --git a/src/generatorprofile_p.h b/src/generatorprofile_p.h index 5ab7bb5a7..fda7cf543 100644 --- a/src/generatorprofile_p.h +++ b/src/generatorprofile_p.h @@ -225,8 +225,12 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mExternalVariableMethodCallFamString; std::string mExternalVariableMethodCallFdmString; - std::string mRootFindingInfoObjectFamString; - std::string mRootFindingInfoObjectFdmString; + std::string mRootFindingInfoObjectFamWoevString; + std::string mRootFindingInfoObjectFamWevString; + + std::string mRootFindingInfoObjectFdmWoevString; + std::string mRootFindingInfoObjectFdmWevString; + std::string mExternNlaSolveMethodString; std::string mFindRootCallFamString; std::string mFindRootCallFdmString; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index e4bf327ed..1c6ba04d8 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "1e07f5b270d8f8fe62cffa8bcd81bf04804aa9e5"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "3c4d4503bca8066e85c60491ac85a960ec8144bf"; +static const char C_GENERATOR_PROFILE_SHA1[] = "d3c84f25e69c62eaf1a154bf75d4394185cf7e23"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "06014d14cb0b183d9ba4952c56eb36388da5de28"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index d68bb59bc..c85fe9411 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -491,8 +491,10 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->externalVariableMethodCallString(false) + generatorProfile->externalVariableMethodCallString(true); - profileContents += generatorProfile->rootFindingInfoObjectString(false) - + generatorProfile->rootFindingInfoObjectString(true) + profileContents += generatorProfile->rootFindingInfoObjectString(false, false) + + generatorProfile->rootFindingInfoObjectString(false, true) + + generatorProfile->rootFindingInfoObjectString(true, false) + + generatorProfile->rootFindingInfoObjectString(true, true) + generatorProfile->externNlaSolveMethodString() + generatorProfile->findRootCallString(false) + generatorProfile->findRootCallString(true) diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index 7d1a1cc84..1b728eec3 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -819,11 +819,17 @@ describe("GeneratorProfile tests", () => { test("Checking GeneratorProfile.rootFindingInfoObjectString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setRootFindingInfoObjectString(false, "something") - expect(x.rootFindingInfoObjectString(false)).toBe("something") + x.setRootFindingInfoObjectString(false, false, "something") + expect(x.rootFindingInfoObjectString(false, false)).toBe("something") - x.setRootFindingInfoObjectString(true, "something") - expect(x.rootFindingInfoObjectString(true)).toBe("something") + x.setRootFindingInfoObjectString(false, true, "something") + expect(x.rootFindingInfoObjectString(false, true)).toBe("something") + + x.setRootFindingInfoObjectString(true, false, "something") + expect(x.rootFindingInfoObjectString(true, false)).toBe("something") + + x.setRootFindingInfoObjectString(true, true, "something") + expect(x.rootFindingInfoObjectString(true, true)).toBe("something") }); test("Checking GeneratorProfile.externNlaSolveMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 5ec63521c..b3bb6ad3a 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -724,7 +724,7 @@ def test_implementation_compute_rates_method_string(self): self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeRatesMethodString(False)) self.assertEqual( - 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n{\n[CODE]}\n', + 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationComputeRatesMethodString(True)) g.setImplementationComputeRatesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeRatesMethodString(True)) @@ -741,7 +741,7 @@ def test_implementation_compute_variables_method_string(self): self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(False, False)) self.assertEqual( - 'void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n{\n[CODE]}\n', + 'void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationComputeVariablesMethodString(False, True)) g.setImplementationComputeVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(False, True)) @@ -753,7 +753,7 @@ def test_implementation_compute_variables_method_string(self): self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(True, False)) self.assertEqual( - 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n{\n[CODE]}\n', + 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationComputeVariablesMethodString(True, True)) g.setImplementationComputeVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(True, True)) @@ -1006,7 +1006,7 @@ def test_interface_compute_rates_method_string(self): self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeRatesMethodString(False)) self.assertEqual( - 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n', + 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n', g.interfaceComputeRatesMethodString(True)) g.setInterfaceComputeRatesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeRatesMethodString(True)) @@ -1023,7 +1023,7 @@ def test_interface_compute_variables_method_string(self): self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(False, False)) self.assertEqual( - 'void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n', + 'void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n', g.interfaceComputeVariablesMethodString(False, True)) g.setInterfaceComputeVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(False, True)) @@ -1035,7 +1035,7 @@ def test_interface_compute_variables_method_string(self): self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(True, False)) self.assertEqual( - 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n', + 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n', g.interfaceComputeVariablesMethodString(True, True)) g.setInterfaceComputeVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(True, True)) @@ -1677,13 +1677,13 @@ def test_external_variable_method_type_definition_string(self): g = GeneratorProfile() self.assertEqual( - 'typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index);\n', + 'typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n', g.externalVariableMethodTypeDefinitionString(False)) g.setExternalVariableMethodTypeDefinitionString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodTypeDefinitionString(False)) self.assertEqual( - 'typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index);\n', + 'typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n', g.externalVariableMethodTypeDefinitionString(True)) g.setExternalVariableMethodTypeDefinitionString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodTypeDefinitionString(True)) @@ -1693,12 +1693,12 @@ def test_external_variable_method_call_string(self): g = GeneratorProfile() - self.assertEqual('externalVariable(constants, computedConstants, algebraic, [INDEX])', + self.assertEqual('externalVariable(constants, computedConstants, algebraic, externals, [INDEX])', g.externalVariableMethodCallString(False)) g.setExternalVariableMethodCallString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodCallString(False)) - self.assertEqual('externalVariable(voi, states, rates, constants, computedConstants, algebraic, [INDEX])', + self.assertEqual('externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, [INDEX])', g.externalVariableMethodCallString(True)) g.setExternalVariableMethodCallString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodCallString(True)) @@ -1708,13 +1708,21 @@ def test_root_finding_info_object_string(self): g = GeneratorProfile() - self.assertEqual('typedef struct {\n double *constants;\n double *computedConstants;\n double *algebraic;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(False)) - g.setRootFindingInfoObjectString(False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(False)) + self.assertEqual('typedef struct {\n double *constants;\n double *computedConstants;\n double *algebraic;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(False, False)) + g.setRootFindingInfoObjectString(False, False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(False, False)) - self.assertEqual('typedef struct {\n double voi;\n double *states;\n double *rates;\n double *constants;\n double *computedConstants;\n double *algebraic;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(True)) - g.setRootFindingInfoObjectString(True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(True)) + self.assertEqual('typedef struct {\n double *constants;\n double *computedConstants;\n double *algebraic;\n double *externals;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(False, True)) + g.setRootFindingInfoObjectString(False, True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(False, True)) + + self.assertEqual('typedef struct {\n double voi;\n double *states;\n double *rates;\n double *constants;\n double *computedConstants;\n double *algebraic;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(True, False)) + g.setRootFindingInfoObjectString(True, False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(True, False)) + + self.assertEqual('typedef struct {\n double voi;\n double *states;\n double *rates;\n double *constants;\n double *computedConstants;\n double *algebraic;\n double *externals;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(True, True)) + g.setRootFindingInfoObjectString(True, True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(True, True)) def test_extern_nla_solve_method_string(self): from libcellml import GeneratorProfile diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index c95a5112a..c61172e51 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -342,18 +342,34 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("algebraic", generatorProfile->algebraicArrayString()); EXPECT_EQ("externals", generatorProfile->externalArrayString()); - EXPECT_EQ("typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(false)); - EXPECT_EQ("typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(true)); + EXPECT_EQ("typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(false)); + EXPECT_EQ("typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(true)); - EXPECT_EQ("externalVariable(constants, computedConstants, algebraic, [INDEX])", generatorProfile->externalVariableMethodCallString(false)); - EXPECT_EQ("externalVariable(voi, states, rates, constants, computedConstants, algebraic, [INDEX])", generatorProfile->externalVariableMethodCallString(true)); + EXPECT_EQ("externalVariable(constants, computedConstants, algebraic, externals, [INDEX])", generatorProfile->externalVariableMethodCallString(false)); + EXPECT_EQ("externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, [INDEX])", generatorProfile->externalVariableMethodCallString(true)); EXPECT_EQ("typedef struct {\n" " double *constants;\n" " double *computedConstants;\n" " double *algebraic;\n" "} RootFindingInfo;\n", - generatorProfile->rootFindingInfoObjectString(false)); + generatorProfile->rootFindingInfoObjectString(false, false)); + EXPECT_EQ("typedef struct {\n" + " double *constants;\n" + " double *computedConstants;\n" + " double *algebraic;\n" + " double *externals;\n" + "} RootFindingInfo;\n", + generatorProfile->rootFindingInfoObjectString(false, true)); + EXPECT_EQ("typedef struct {\n" + " double voi;\n" + " double *states;\n" + " double *rates;\n" + " double *constants;\n" + " double *computedConstants;\n" + " double *algebraic;\n" + "} RootFindingInfo;\n", + generatorProfile->rootFindingInfoObjectString(true, false)); EXPECT_EQ("typedef struct {\n" " double voi;\n" " double *states;\n" @@ -361,8 +377,9 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) " double *constants;\n" " double *computedConstants;\n" " double *algebraic;\n" + " double *externals;\n" "} RootFindingInfo;\n", - generatorProfile->rootFindingInfoObjectString(true)); + generatorProfile->rootFindingInfoObjectString(true, true)); EXPECT_EQ("extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *),\n" " double *u, size_t n, void *data);\n", generatorProfile->externNlaSolveMethodString()); @@ -526,9 +543,9 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationComputeRatesMethodString(false)); - EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n", + EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n", generatorProfile->interfaceComputeRatesMethodString(true)); - EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n" + EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", @@ -542,9 +559,9 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationComputeVariablesMethodString(false, false)); - EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n", + EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n", generatorProfile->interfaceComputeVariablesMethodString(false, true)); - EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n" + EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", @@ -558,9 +575,9 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationComputeVariablesMethodString(true, false)); - EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable);\n", + EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n", generatorProfile->interfaceComputeVariablesMethodString(true, true)); - EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable)\n" + EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", @@ -939,8 +956,10 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setExternalVariableMethodCallString(false, value); generatorProfile->setExternalVariableMethodCallString(true, value); - generatorProfile->setRootFindingInfoObjectString(false, value); - generatorProfile->setRootFindingInfoObjectString(true, value); + generatorProfile->setRootFindingInfoObjectString(false, false, value); + generatorProfile->setRootFindingInfoObjectString(false, true, value); + generatorProfile->setRootFindingInfoObjectString(true, false, value); + generatorProfile->setRootFindingInfoObjectString(true, true, value); generatorProfile->setExternNlaSolveMethodString(value); generatorProfile->setFindRootCallString(false, value); generatorProfile->setFindRootCallString(true, value); @@ -1080,8 +1099,10 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->externalVariableMethodCallString(false)); EXPECT_EQ(value, generatorProfile->externalVariableMethodCallString(true)); - EXPECT_EQ(value, generatorProfile->rootFindingInfoObjectString(false)); - EXPECT_EQ(value, generatorProfile->rootFindingInfoObjectString(true)); + EXPECT_EQ(value, generatorProfile->rootFindingInfoObjectString(false, false)); + EXPECT_EQ(value, generatorProfile->rootFindingInfoObjectString(false, true)); + EXPECT_EQ(value, generatorProfile->rootFindingInfoObjectString(true, false)); + EXPECT_EQ(value, generatorProfile->rootFindingInfoObjectString(true, true)); EXPECT_EQ(value, generatorProfile->externNlaSolveMethodString()); EXPECT_EQ(value, generatorProfile->findRootCallString(false)); EXPECT_EQ(value, generatorProfile->findRootCallString(true)); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 6e39ffddf..97aab6bf2 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -84,8 +84,8 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); algebraic[0] = externals[0]; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index c68c54a28..2d7a13452 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -30,8 +30,8 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 953b054c8..0e366b97b 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -51,6 +51,6 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(constants, computed_constants, algebraic, 0) +def compute_variables(constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) algebraic[0] = externals[0] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index dd58522e6..a1a60e49f 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -89,7 +89,7 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index c68c54a28..2d7a13452 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -30,8 +30,8 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 8be4ddcd1..927ddba3f 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -55,5 +55,5 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(constants, computed_constants, algebraic, 0) +def compute_variables(constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c index ee21f220e..d58310558 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c @@ -85,9 +85,9 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(constants, computedConstants, algebraic, 0); - externals[1] = externalVariable(constants, computedConstants, algebraic, 1); - externals[2] = externalVariable(constants, computedConstants, algebraic, 2); + externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); + externals[1] = externalVariable(constants, computedConstants, algebraic, externals, 1); + externals[2] = externalVariable(constants, computedConstants, algebraic, externals, 2); } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h index 8ea01811f..eb786b587 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h @@ -30,8 +30,8 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py index 65c6876d4..e72866bd3 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py @@ -52,7 +52,7 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(constants, computed_constants, algebraic, 0) - externals[1] = external_variable(constants, computed_constants, algebraic, 1) - externals[2] = external_variable(constants, computed_constants, algebraic, 2) +def compute_variables(constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) + externals[1] = external_variable(constants, computed_constants, algebraic, externals, 1) + externals[2] = external_variable(constants, computed_constants, algebraic, externals, 2) diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index de3a3ab80..e47410774 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -86,10 +86,10 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(constants, computedConstants, algebraic, 0); - externals[1] = externalVariable(constants, computedConstants, algebraic, 1); + externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); + externals[1] = externalVariable(constants, computedConstants, algebraic, externals, 1); algebraic[0] = 1000.0*3.14*externals[1]*externals[1]*externals[0]; algebraic[1] = 0.02*algebraic[0]; } diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index c312a35c7..824fecf42 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -30,8 +30,8 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index c45a649c6..88706ddad 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -53,8 +53,8 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(constants, computed_constants, algebraic, 0) - externals[1] = external_variable(constants, computed_constants, algebraic, 1) +def compute_variables(constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) + externals[1] = external_variable(constants, computed_constants, algebraic, externals, 1) algebraic[0] = 1000.0*3.14*externals[1]*externals[1]*externals[0] algebraic[1] = 0.02*algebraic[0] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 20a0c70ea..5d1bf7544 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -133,9 +133,9 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); @@ -151,9 +151,9 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = algebraic[7]*(1.0-states[3])-algebraic[8]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index 35a6bd9c3..f07a94f94 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -34,9 +34,9 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 35757ff10..18b9522bc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -103,8 +103,8 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) @@ -120,8 +120,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, rates[3] = algebraic[7]*(1.0-states[3])-algebraic[8]*states[3] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 223249ed9..521c1b0c7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -132,10 +132,10 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[1] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[1] = constants[2]*(states[0]-externals[0]); algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); @@ -151,9 +151,9 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[1] = constants[2]*(states[0]-externals[0]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index 35a6bd9c3..f07a94f94 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -34,9 +34,9 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index c00871301..ca7257bd1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -102,9 +102,9 @@ def compute_computed_constants(constants, computed_constants): computed_constants[1] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[1] = constants[2]*(states[0]-externals[0]) algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) @@ -120,8 +120,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[1] = constants[2]*(states[0]-externals[0]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 708762d5a..1e9624927 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -132,10 +132,10 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[0]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); @@ -151,7 +151,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); @@ -162,5 +162,5 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(states[0]/80.0); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index 35a6bd9c3..f07a94f94 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -34,9 +34,9 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 47529b9f1..7d66e0529 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -102,9 +102,9 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[0]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) @@ -120,7 +120,7 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) @@ -130,4 +130,4 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(states[0]/80.0) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 37c38f09a..7b681079c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -133,10 +133,10 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); @@ -151,10 +151,10 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = algebraic[7]*(1.0-states[3])-externals[1]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[0] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index 35a6bd9c3..f07a94f94 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -34,9 +34,9 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index dcce03903..76a6c723f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -103,9 +103,9 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) @@ -120,9 +120,9 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, rates[3] = algebraic[7]*(1.0-states[3])-externals[1]*states[3] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[0] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index b52e837c2..4ae8c6f8c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -129,11 +129,11 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[4] = externals[0]-10.613; algebraic[1] = constants[1]*(states[0]-algebraic[4]); algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]); @@ -151,10 +151,10 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[4] = externals[0]-10.613; algebraic[1] = constants[1]*(states[0]-algebraic[4]); algebraic[5] = externals[0]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index 35a6bd9c3..f07a94f94 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -34,9 +34,9 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 87f39ea1b..6d69149ce 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -100,10 +100,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[4] = externals[0]-10.613 algebraic[1] = constants[1]*(states[0]-algebraic[4]) algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]) @@ -121,9 +121,9 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[4] = externals[0]-10.613 algebraic[1] = constants[1]*(states[0]-algebraic[4]) algebraic[5] = externals[0]-115.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index a1c9778c8..479c2a1cb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -131,11 +131,11 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[0]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); @@ -151,10 +151,10 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { algebraic[1] = constants[1]*(states[0]-computedConstants[0]); - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); @@ -163,5 +163,5 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(states[0]/80.0); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index 35a6bd9c3..f07a94f94 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -34,9 +34,9 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index e72a244f0..8e4407c2f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -101,10 +101,10 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[0]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) @@ -120,9 +120,9 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): algebraic[1] = constants[1]*(states[0]-computed_constants[0]) - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) @@ -131,4 +131,4 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(states[0]/80.0) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 7c679fed8..10e2b10fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -131,9 +131,9 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[6] = 0.07*exp(externals[0]/20.0); algebraic[7] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0); rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0]; @@ -142,12 +142,12 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[1] = constants[2]*(externals[0]-computedConstants[0]); - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); algebraic[3] = constants[3]*pow(externals[1], 3.0)*states[0]*(externals[0]-computedConstants[1]); algebraic[4] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(externals[0]/18.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index 35a6bd9c3..f07a94f94 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -34,9 +34,9 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index d1dcd1929..7a00357ca 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -101,8 +101,8 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[6] = 0.07*exp(externals[0]/20.0) algebraic[7] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0) rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0] @@ -111,11 +111,11 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[1] = constants[2]*(externals[0]-computed_constants[0]) - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) algebraic[3] = constants[3]*pow(externals[1], 3.0)*states[0]*(externals[0]-computed_constants[1]) algebraic[4] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(externals[0]/18.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index f1285c30d..64b8a5ae6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -132,26 +132,26 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[3] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0); algebraic[4] = 4.0*exp(externals[0]/18.0); rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1]; algebraic[5] = 0.07*exp(externals[0]/20.0); algebraic[6] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0); rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0]; - externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 2); + externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); algebraic[7] = 0.125*exp(externals[0]/80.0); rates[2] = externals[2]*(1.0-states[2])-algebraic[7]*states[2]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[1] = constants[2]*(externals[0]-computedConstants[0]); - externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 2); - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 1); + externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[0]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index 35a6bd9c3..f07a94f94 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -34,9 +34,9 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index b726fdfa0..f86b3fb63 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -102,23 +102,23 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[3] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0) algebraic[4] = 4.0*exp(externals[0]/18.0) rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1] algebraic[5] = 0.07*exp(externals[0]/20.0) algebraic[6] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0) rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0] - externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 2) + externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) algebraic[7] = 0.125*exp(externals[0]/80.0) rates[2] = externals[2]*(1.0-states[2])-algebraic[7]*states[2] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[1] = constants[2]*(externals[0]-computed_constants[0]) - externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 2) - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 1) + externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[0]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index d6aed64a5..ba5aba224 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -132,12 +132,12 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraic[1] = constants[2]*(states[0]-computedConstants[0]); algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; algebraic[6] = 0.07*exp(states[0]/20.0); @@ -148,10 +148,10 @@ void computeRates(double voi, double *states, double *rates, double *constants, rates[2] = algebraic[8]*(1.0-states[2])-algebraic[9]*states[2]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index 35a6bd9c3..f07a94f94 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -34,9 +34,9 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 5ce36e54a..4373274a1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -102,11 +102,11 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic[1] = constants[2]*(states[0]-computed_constants[0]) algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] algebraic[6] = 0.07*exp(states[0]/20.0) @@ -117,9 +117,9 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, rates[2] = algebraic[8]*(1.0-states[2])-algebraic[9]*states[2] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, external_variable): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, 0) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 439e1bb42..7e303a655 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -100,8 +100,8 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(constants, computedConstants, algebraic, 0); + externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+externals[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]); } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 49b5d66b7..055ffae83 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -30,8 +30,8 @@ double * createExternalsArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); void initialiseVariables(double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 399e6d5bb..67e7d2469 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -66,6 +66,6 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic, external_variable): - externals[0] = external_variable(constants, computed_constants, algebraic, 0) +def compute_variables(constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+externals[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) From 4bf1afc386a797e9b96db5ab9919c5b5ff66beea Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 20 Aug 2024 16:32:17 +0200 Subject: [PATCH 47/74] Addressed various coverage issues as a result of our work on issue #1247. --- src/analyser.cpp | 102 +++--- src/analyserequation.cpp | 19 -- src/analyserequation_p.h | 1 - src/api/libcellml/analyserequation.h | 29 -- src/bindings/interface/analyserequation.i | 9 - src/bindings/javascript/analyserequation.cpp | 3 - src/debug.cpp | 10 - src/generator.cpp | 95 +++--- src/generator_p.h | 2 - src/utilities.cpp | 50 +-- tests/coverage/coverage.cpp | 18 +- tests/resources/coverage/generator/model.c | 302 +++++++++--------- tests/resources/coverage/generator/model.h | 9 +- .../generator/model.implementation.out | 294 +++++++++-------- .../coverage/generator/model.interface.out | 7 +- .../generator/model.modified.profile.c | 302 +++++++++--------- .../generator/model.modified.profile.h | 9 +- .../generator/model.modified.profile.py | 298 ++++++++--------- tests/resources/coverage/generator/model.out | 282 ++++++++-------- tests/resources/coverage/generator/model.py | 298 ++++++++--------- 20 files changed, 1028 insertions(+), 1111 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index 519f9c9df..e1a3ca780 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -2243,8 +2243,7 @@ bool Analyser::AnalyserImpl::isStateRateBased(const AnalyserEquationPtr &equatio if ((dependency->type() == AnalyserEquation::Type::ODE) || ((dependency->type() == AnalyserEquation::Type::NLA) - && (dependency->stateCount() == 1) - && (dependency->state(0)->type() == AnalyserVariable::Type::STATE)) + && (dependency->stateCount() == 1)) || isStateRateBased(dependency, checkedEquations)) { return true; } @@ -2862,31 +2861,31 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) for (const auto &internalVariable : mInternalVariables) { // Determine the type of the variable. - AnalyserVariable::Type type; + AnalyserVariable::Type variableType; if (internalVariable->mIsExternalVariable) { - type = AnalyserVariable::Type::EXTERNAL; + variableType = AnalyserVariable::Type::EXTERNAL; } else { switch (internalVariable->mType) { case AnalyserInternalVariable::Type::STATE: - type = AnalyserVariable::Type::STATE; + variableType = AnalyserVariable::Type::STATE; break; case AnalyserInternalVariable::Type::CONSTANT: - type = AnalyserVariable::Type::CONSTANT; + variableType = AnalyserVariable::Type::CONSTANT; break; case AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT: case AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT: - type = AnalyserVariable::Type::COMPUTED_CONSTANT; + variableType = AnalyserVariable::Type::COMPUTED_CONSTANT; break; case AnalyserInternalVariable::Type::ALGEBRAIC: case AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC: - type = AnalyserVariable::Type::ALGEBRAIC; + variableType = AnalyserVariable::Type::ALGEBRAIC; break; - default: // AnalyserVariable::Type::VARIABLE_OF_INTEGRATION. + default: // AnalyserInternalVariable::Type::VARIABLE_OF_INTEGRATION. // This is the variable of integration, so skip it. continue; @@ -2896,7 +2895,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Retrieve the equations used to compute the variable. AnalyserEquationPtrs equations; - auto nlaEquation = false; + auto isNlaEquation = false; for (const auto &internalEquation : mInternalEquations) { if (std::find(internalEquation->mUnknownVariables.begin(), internalEquation->mUnknownVariables.end(), internalVariable) != internalEquation->mUnknownVariables.end()) { @@ -2904,32 +2903,32 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) if ((aie2aetMappings.find(internalEquation) != aie2aetMappings.end()) && (aie2aetMappings[internalEquation] == AnalyserEquation::Type::NLA)) { - nlaEquation = true; + isNlaEquation = true; } } } // Correct the type of the variable if it is a computed constant that is computed using an NLA equation. - if ((type == AnalyserVariable::Type::COMPUTED_CONSTANT) && nlaEquation) { - type = AnalyserVariable::Type::ALGEBRAIC; + if ((variableType == AnalyserVariable::Type::COMPUTED_CONSTANT) && isNlaEquation) { + variableType = AnalyserVariable::Type::ALGEBRAIC; } // Populate and keep track of the state/variable. auto variable = AnalyserVariable::AnalyserVariableImpl::create(); - variable->mPimpl->populate(type, - (type == AnalyserVariable::Type::STATE) ? + variable->mPimpl->populate(variableType, + (variableType == AnalyserVariable::Type::STATE) ? ++stateIndex : - (type == AnalyserVariable::Type::CONSTANT) ? + (variableType == AnalyserVariable::Type::CONSTANT) ? ++constantIndex : - (type == AnalyserVariable::Type::COMPUTED_CONSTANT) ? + (variableType == AnalyserVariable::Type::COMPUTED_CONSTANT) ? ++computedConstantIndex : - (type == AnalyserVariable::Type::ALGEBRAIC) ? + (variableType == AnalyserVariable::Type::ALGEBRAIC) ? ++algebraicIndex : ++externalIndex, - (type == AnalyserVariable::Type::EXTERNAL) ? + (variableType == AnalyserVariable::Type::EXTERNAL) ? nullptr : internalVariable->mInitialisingVariable, internalVariable->mVariable, @@ -2938,31 +2937,16 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) aiv2avMappings.emplace(internalVariable, variable); v2avMappings.emplace(internalVariable->mVariable, variable); - switch (type) { - case AnalyserVariable::Type::STATE: + if (variableType == AnalyserVariable::Type::STATE) { mModel->mPimpl->mStates.push_back(variable); - - break; - case AnalyserVariable::Type::CONSTANT: + } else if (variableType == AnalyserVariable::Type::CONSTANT) { mModel->mPimpl->mConstants.push_back(variable); - - break; - case AnalyserVariable::Type::COMPUTED_CONSTANT: + } else if (variableType == AnalyserVariable::Type::COMPUTED_CONSTANT) { mModel->mPimpl->mComputedConstants.push_back(variable); - - break; - case AnalyserVariable::Type::ALGEBRAIC: + } else if (variableType == AnalyserVariable::Type::ALGEBRAIC) { mModel->mPimpl->mAlgebraic.push_back(variable); - - break; - case AnalyserVariable::Type::EXTERNAL: + } else { // AnalyserVariable::Type::EXTERNAL. mModel->mPimpl->mExternals.push_back(variable); - - break; - default: // AnalyserVariable::Type::VARIABLE_OF_INTEGRATION. - // This is the variable of integration, so skip it. - - break; } } @@ -2983,9 +2967,9 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Manipulate the equation, if needed. - auto type = aie2aetMappings[internalEquation]; + auto equationType = aie2aetMappings[internalEquation]; - switch (type) { + switch (equationType) { case AnalyserEquation::Type::NLA: // The equation is currently of the form LHS = RHS, but we want it // in the form LHS-RHS, so replace the equality element with a minus @@ -3014,7 +2998,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) VariablePtrs variableDependencies; - if (type == AnalyserEquation::Type::EXTERNAL) { + if (equationType == AnalyserEquation::Type::EXTERNAL) { for (const auto &unknownVariable : internalEquation->mUnknownVariables) { for (const auto &dependency : unknownVariable->mDependencies) { variableDependencies.push_back(dependency); @@ -3052,40 +3036,28 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) auto equation = aie2aeMappings[internalEquation]; - equation->mPimpl->mType = type; - equation->mPimpl->mAst = (type == AnalyserEquation::Type::EXTERNAL) ? + equation->mPimpl->mType = equationType; + equation->mPimpl->mAst = (equationType == AnalyserEquation::Type::EXTERNAL) ? nullptr : internalEquation->mAst; equation->mPimpl->mNlaSystemIndex = internalEquation->mNlaSystemIndex; for (const auto &unknownVariable : internalEquation->mUnknownVariables) { + // Keep track of the variable that the equation computes. + // Note: an unknown variable cannot be the variable of integration (since it cannot be computed) or a + // constant (snce it is not computed but set), so no need to check for those. + auto variable = aiv2avMappings[unknownVariable]; + auto variableType = variable->type(); - switch (variable->type()) { - case AnalyserVariable::Type::STATE: + if (variableType == AnalyserVariable::Type::STATE) { equation->mPimpl->mStates.push_back(variable); - - break; - case AnalyserVariable::Type::CONSTANT: - equation->mPimpl->mConstants.push_back(variable); - - break; - case AnalyserVariable::Type::COMPUTED_CONSTANT: + } else if (variableType == AnalyserVariable::Type::COMPUTED_CONSTANT) { equation->mPimpl->mComputedConstants.push_back(variable); - - break; - case AnalyserVariable::Type::ALGEBRAIC: + } else if (variableType == AnalyserVariable::Type::ALGEBRAIC) { equation->mPimpl->mAlgebraic.push_back(variable); - - break; - case AnalyserVariable::Type::EXTERNAL: + } else { // AnalyserVariable::Type::EXTERNAL. equation->mPimpl->mExternals.push_back(variable); - - break; - default: // AnalyserVariable::Type::VARIABLE_OF_INTEGRATION. - // This is the variable of integration, which cannot be computed. - - break; } } diff --git a/src/analyserequation.cpp b/src/analyserequation.cpp index d5d13f9f3..c559bfe64 100644 --- a/src/analyserequation.cpp +++ b/src/analyserequation.cpp @@ -157,25 +157,6 @@ AnalyserVariablePtr AnalyserEquation::state(size_t index) const return mPimpl->mStates[index]; } -size_t AnalyserEquation::constantCount() const -{ - return mPimpl->mConstants.size(); -} - -std::vector AnalyserEquation::constants() const -{ - return mPimpl->mConstants; -} - -AnalyserVariablePtr AnalyserEquation::constant(size_t index) const -{ - if (index >= mPimpl->mConstants.size()) { - return {}; - } - - return mPimpl->mConstants[index]; -} - size_t AnalyserEquation::computedConstantCount() const { return mPimpl->mComputedConstants.size(); diff --git a/src/analyserequation_p.h b/src/analyserequation_p.h index d0a167f4a..a75f6faff 100644 --- a/src/analyserequation_p.h +++ b/src/analyserequation_p.h @@ -35,7 +35,6 @@ struct AnalyserEquation::AnalyserEquationImpl bool mIsStateRateBased = false; std::vector mStates; - std::vector mConstants; std::vector mComputedConstants; std::vector mAlgebraic; std::vector mExternals; diff --git a/src/api/libcellml/analyserequation.h b/src/api/libcellml/analyserequation.h index 9c83fa402..2e5f601b1 100644 --- a/src/api/libcellml/analyserequation.h +++ b/src/api/libcellml/analyserequation.h @@ -194,35 +194,6 @@ class LIBCELLML_EXPORT AnalyserEquation */ AnalyserVariablePtr state(size_t index) const; - /** - * @brief Get the number of constant computed by this @ref AnalyserEquation. - * - * Return the number of constants computed by this @ref AnalyserEquation. - * - * @return The number of constants. - */ - size_t constantCount() const; - - /** - * @brief Get the constants computed by this @ref AnalyserEquation. - * - * Return the constants computed by this @ref AnalyserEquation. - * - * @return The constants as a @c std::vector. - */ - std::vector constants() const; - - /** - * @brief Get the constant, at @p index, computed by this @ref AnalyserEquation. - * - * Return the constant, at @p index, computed by this @ref AnalyserEquation. - * - * @param index The index of the constant to return. - * - * @return The constant, at @p index, on success, @c nullptr on failure. - */ - AnalyserVariablePtr constant(size_t index) const; - /** * @brief Get the number of computed constants computed by this @ref AnalyserEquation. * diff --git a/src/bindings/interface/analyserequation.i b/src/bindings/interface/analyserequation.i index 3e7f3345b..e75f49f9a 100644 --- a/src/bindings/interface/analyserequation.i +++ b/src/bindings/interface/analyserequation.i @@ -52,15 +52,6 @@ %feature("docstring") libcellml::AnalyserEquation::state "Returns the state, at the given index, computed by this :class:`AnalyserEquation` object."; -%feature("docstring") libcellml::AnalyserEquation::constantCount -"Returns the number of constants computed by this :class:`AnalyserEquation` object."; - -%feature("docstring") libcellml::AnalyserEquation::constants -"Returns the constants computed by this :class:`AnalyserEquation` object."; - -%feature("docstring") libcellml::AnalyserEquation::constant -"Returns the constant, at the given index, computed by this :class:`AnalyserEquation` object."; - %feature("docstring") libcellml::AnalyserEquation::computedConstantCount "Returns the number of computed constants computed by this :class:`AnalyserEquation` object."; diff --git a/src/bindings/javascript/analyserequation.cpp b/src/bindings/javascript/analyserequation.cpp index ed04c4c13..5f428b040 100644 --- a/src/bindings/javascript/analyserequation.cpp +++ b/src/bindings/javascript/analyserequation.cpp @@ -48,9 +48,6 @@ EMSCRIPTEN_BINDINGS(libcellml_analyserequation) .function("stateCount", &libcellml::AnalyserEquation::stateCount) .function("states", select_overload() const>(&libcellml::AnalyserEquation::states)) .function("state", select_overload(&libcellml::AnalyserEquation::state)) - .function("constantCount", &libcellml::AnalyserEquation::constantCount) - .function("constants", select_overload() const>(&libcellml::AnalyserEquation::constants)) - .function("constant", select_overload(&libcellml::AnalyserEquation::constant)) .function("computedConstantCount", &libcellml::AnalyserEquation::computedConstantCount) .function("computedConstants", &libcellml::AnalyserEquation::computedConstants) .function("computedConstant", &libcellml::AnalyserEquation::computedConstant) diff --git a/src/debug.cpp b/src/debug.cpp index a1a92ac88..f16c75456 100644 --- a/src/debug.cpp +++ b/src/debug.cpp @@ -96,16 +96,6 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) Debug() << "\nNo states"; } - if (eqn->constantCount() != 0) { - Debug() << "\nConstants:"; - - for (const auto &var : eqn->constants()) { - Debug() << " - " << var->variable()->name(); - } - } else { - Debug() << "\nNo constants"; - } - if (eqn->computedConstantCount() != 0) { Debug() << "\nComputed constants:"; diff --git a/src/generator.cpp b/src/generator.cpp index 7f5a6261d..ac689f905 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -64,22 +64,6 @@ bool Generator::GeneratorImpl::modelHasNlas() const } } -AnalyserVariablePtr Generator::GeneratorImpl::doAnalyserVariable(const VariablePtr &variable, - const std::vector &variables) const -{ - AnalyserVariablePtr res; - - for (const auto &var : variables) { - if (mModel->areEquivalentVariables(variable, var->variable())) { - res = var; - - break; - } - } - - return res; -} - AnalyserVariablePtr Generator::GeneratorImpl::analyserVariable(const VariablePtr &variable) const { // Find and return the analyser variable associated with the given variable. @@ -92,7 +76,29 @@ AnalyserVariablePtr Generator::GeneratorImpl::analyserVariable(const VariablePtr && mModel->areEquivalentVariables(variable, modelVoiVariable)) { res = modelVoi; } else { - res = doAnalyserVariable(variable, variables(mModel)); + // Normally, we would have something like: + // + // for (const auto &modelVariable : variables(mModel)) { + // if (mModel->areEquivalentVariables(variable, modelVariable->variable())) { + // res = modelVariable; + // + // break; + // } + // } + // + // but we always have variables, so llvm-cov will complain that the false branch of our for loop is never + // reached. The below code is a bit more verbose but at least it makes llvm-cov happy. + + auto modelVariables = variables(mModel); + auto modelVariable = modelVariables.begin(); + + do { + if (mModel->areEquivalentVariables(variable, (*modelVariable)->variable())) { + res = *modelVariable; + } else { + ++modelVariable; + } + } while (res == nullptr); } return res; @@ -246,8 +252,9 @@ void Generator::GeneratorImpl::addOriginCommentCode() "Python"; profileInformation += " profile of"; - mCode += replace(mProfile->commentString(), - "[CODE]", replace(replace(mProfile->originCommentString(), "[PROFILE_INFORMATION]", profileInformation), "[LIBCELLML_VERSION]", versionString())); + mCode += newLineIfNeeded() + + replace(mProfile->commentString(), + "[CODE]", replace(replace(mProfile->originCommentString(), "[PROFILE_INFORMATION]", profileInformation), "[LIBCELLML_VERSION]", versionString())); } } @@ -302,10 +309,9 @@ void Generator::GeneratorImpl::addVersionAndLibcellmlVersionCode(bool interface) } if (!code.empty()) { - mCode += "\n"; + mCode += newLineIfNeeded() + + code; } - - mCode += code; } void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) @@ -355,10 +361,9 @@ void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) } if (!code.empty()) { - mCode += "\n"; + mCode += newLineIfNeeded() + + code; } - - mCode += code; } std::string Generator::GeneratorImpl::generateVariableInfoObjectCode(const std::string &objectString) const @@ -427,10 +432,9 @@ void Generator::GeneratorImpl::addInterfaceVariableInfoCode() } if (!code.empty()) { - mCode += "\n"; + mCode += newLineIfNeeded() + + code; } - - mCode += code; } void Generator::GeneratorImpl::doAddImplementationVariableInfoCode(const std::string &variableInfoString, @@ -671,10 +675,9 @@ void Generator::GeneratorImpl::addInterfaceCreateDeleteArrayMethodsCode() } if (!code.empty()) { - mCode += "\n"; + mCode += newLineIfNeeded() + + code; } - - mCode += code; } void Generator::GeneratorImpl::addImplementationCreateDeleteArrayMethodsCode() @@ -718,7 +721,7 @@ void Generator::GeneratorImpl::addExternalVariableMethodTypeDefinitionCode() auto externalVariableMethodTypeDefinitionString = mProfile->externalVariableMethodTypeDefinitionString(modelHasOdes()); if (!externalVariableMethodTypeDefinitionString.empty()) { - mCode += "\n" + mCode += newLineIfNeeded() + externalVariableMethodTypeDefinitionString; } } @@ -748,6 +751,9 @@ void Generator::GeneratorImpl::addNlaSystemsCode() && !mProfile->objectiveFunctionMethodString(modelHasOdes()).empty() && !mProfile->findRootMethodString(modelHasOdes()).empty() && !mProfile->nlaSolveCallString(modelHasOdes()).empty()) { + // Note: only states and algebraic variables can be computed through an NLA system. Constants, computed + // constants, and external variables cannot, by definition, be computed through an NLA system. + std::vector handledNlaEquations; for (const auto &equation : mModel->equations()) { @@ -760,13 +766,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() for (const auto &variable : variables) { auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - (variable->type() == AnalyserVariable::Type::CONSTANT) ? - mProfile->constantsArrayString() : - (variable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) ? - mProfile->computedConstantsArrayString() : - (variable->type() == AnalyserVariable::Type::ALGEBRAIC) ? - mProfile->algebraicArrayString() : - mProfile->externalArrayString(); + mProfile->algebraicArrayString(); methodBody += mProfile->indentString() + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() @@ -809,9 +809,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() for (const auto &variable : variables) { auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - (variable->type() == AnalyserVariable::Type::ALGEBRAIC) ? - mProfile->algebraicArrayString() : - mProfile->externalArrayString(); + mProfile->algebraicArrayString(); methodBody += mProfile->indentString() + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() @@ -835,9 +833,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() for (const auto &variable : variables) { auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - (variable->type() == AnalyserVariable::Type::ALGEBRAIC) ? - mProfile->algebraicArrayString() : - mProfile->externalArrayString(); + mProfile->algebraicArrayString(); methodBody += mProfile->indentString() + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() @@ -1802,10 +1798,9 @@ void Generator::GeneratorImpl::addInterfaceComputeModelMethodsCode() } if (!code.empty()) { - mCode += "\n"; + mCode += newLineIfNeeded() + + code; } - - mCode += code; } void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(std::vector &remainingEquations) @@ -1831,10 +1826,6 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st auto crtConstant = std::find_if(constants.begin(), constants.end(), [=](const AnalyserVariablePtr &av) -> bool { return initialisingComponent->variable(initialValue)->hasEquivalentVariable(av->variable()); }); - if (crtConstant == constants.end()) { - break; - } - constant = crtConstant; initialisingVariable = (*constant)->variable(); initialValue = initialisingVariable->initialValue(); diff --git a/src/generator_p.h b/src/generator_p.h index 05c3298a6..8e4308c9c 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -44,8 +44,6 @@ struct Generator::GeneratorImpl bool modelHasOdes() const; bool modelHasNlas() const; - AnalyserVariablePtr doAnalyserVariable(const VariablePtr &variable, - const std::vector &variables) const; AnalyserVariablePtr analyserVariable(const VariablePtr &variable) const; double scalingFactor(const VariablePtr &variable) const; diff --git a/src/utilities.cpp b/src/utilities.cpp index 73473b673..996fc653f 100644 --- a/src/utilities.cpp +++ b/src/utilities.cpp @@ -1326,34 +1326,16 @@ std::vector variables(const AnalyserModelPtr &model) } auto states = model->states(); - - if (!states.empty()) { - res.insert(res.end(), states.begin(), states.end()); - } - auto constants = model->constants(); - - if (!constants.empty()) { - res.insert(res.end(), constants.begin(), constants.end()); - } - auto computedConstants = model->computedConstants(); - - if (!computedConstants.empty()) { - res.insert(res.end(), computedConstants.begin(), computedConstants.end()); - } - auto algebraic = model->algebraic(); - - if (!algebraic.empty()) { - res.insert(res.end(), algebraic.begin(), algebraic.end()); - } - auto externals = model->externals(); - if (!externals.empty()) { - res.insert(res.end(), externals.begin(), externals.end()); - } + res.insert(res.end(), states.begin(), states.end()); + res.insert(res.end(), constants.begin(), constants.end()); + res.insert(res.end(), computedConstants.begin(), computedConstants.end()); + res.insert(res.end(), algebraic.begin(), algebraic.end()); + res.insert(res.end(), externals.begin(), externals.end()); return res; } @@ -1361,29 +1343,13 @@ std::vector variables(const AnalyserModelPtr &model) std::vector variables(const AnalyserEquationPtr &equation) { auto res = equation->states(); - auto constants = equation->constants(); - - if (!constants.empty()) { - res.insert(res.end(), constants.begin(), constants.end()); - } - auto computedConstants = equation->computedConstants(); - - if (!computedConstants.empty()) { - res.insert(res.end(), computedConstants.begin(), computedConstants.end()); - } - auto algebraic = equation->algebraic(); - - if (!algebraic.empty()) { - res.insert(res.end(), algebraic.begin(), algebraic.end()); - } - auto externals = equation->externals(); - if (!externals.empty()) { - res.insert(res.end(), externals.begin(), externals.end()); - } + res.insert(res.end(), computedConstants.begin(), computedConstants.end()); + res.insert(res.end(), algebraic.begin(), algebraic.end()); + res.insert(res.end(), externals.begin(), externals.end()); return res; } diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index cd9654184..c0ff65534 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -584,6 +584,8 @@ TEST(Coverage, generator) auto analyser = libcellml::Analyser::create(); + analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(model->component("my_component")->variable("eqnPlus"))); + analyser->analyseModel(model); EXPECT_EQ(size_t(0), analyser->errorCount()); @@ -595,8 +597,9 @@ TEST(Coverage, generator) EXPECT_EQ(size_t(1), analyserModel->stateCount()); EXPECT_EQ(size_t(7), analyserModel->constantCount()); - EXPECT_EQ(size_t(200), analyserModel->computedConstantCount()); + EXPECT_EQ(size_t(199), analyserModel->computedConstantCount()); EXPECT_EQ(size_t(2), analyserModel->algebraicCount()); + EXPECT_EQ(size_t(1), analyserModel->externalCount()); EXPECT_EQ(size_t(203), analyserModel->equationCount()); EXPECT_NE(nullptr, analyserModel->voi()); @@ -607,15 +610,23 @@ TEST(Coverage, generator) EXPECT_NE(size_t(0), analyserModel->state(0)->equationCount()); EXPECT_NE(size_t(0), analyserModel->state(0)->equations().size()); EXPECT_NE(nullptr, analyserModel->state(0)->equation(0)); + EXPECT_NE(nullptr, analyserModel->state(0)->equation(0)->state(0)); EXPECT_EQ(nullptr, analyserModel->state(analyserModel->stateCount())); EXPECT_NE(nullptr, analyserModel->constant(0)); EXPECT_EQ(nullptr, analyserModel->constant(analyserModel->constantCount())); EXPECT_NE(nullptr, analyserModel->computedConstant(0)); + EXPECT_NE(nullptr, analyserModel->computedConstant(0)->equation(0)->computedConstant(0)); EXPECT_EQ(nullptr, analyserModel->computedConstant(analyserModel->computedConstantCount())); EXPECT_NE(nullptr, analyserModel->algebraic(0)); + EXPECT_NE(nullptr, analyserModel->algebraic(0)->equation(0)->algebraic(0)); EXPECT_EQ(nullptr, analyserModel->algebraic(analyserModel->algebraicCount())); - EXPECT_EQ(nullptr, analyserModel->external(0)); + EXPECT_NE(nullptr, analyserModel->external(0)); + EXPECT_NE(nullptr, analyserModel->external(0)->equation(0)->external(0)); EXPECT_EQ(nullptr, analyserModel->external(analyserModel->algebraicCount())); + EXPECT_EQ(size_t(1), analyserModel->equation(0)->stateCount()); + EXPECT_EQ(size_t(1), analyserModel->equation(0)->states().size()); + EXPECT_NE(nullptr, analyserModel->equation(0)->state(0)); + EXPECT_EQ(nullptr, analyserModel->equation(0)->state(analyserModel->equation(0)->stateCount())); EXPECT_NE(nullptr, analyserModel->equation(199)); EXPECT_NE(size_t(0), analyserModel->equation(199)->dependencyCount()); EXPECT_NE(size_t(0), analyserModel->equation(199)->dependencies().size()); @@ -746,6 +757,9 @@ TEST(Coverage, generator) profile->setImplementationDeleteArrayMethodString(""); + profile->setImplementationInitialiseVariablesMethodString(false, ""); + profile->setImplementationInitialiseVariablesMethodString(true, ""); + profile->setImplementationComputeVariablesMethodString(false, false, ""); profile->setImplementationComputeVariablesMethodString(false, true, ""); profile->setImplementationComputeVariablesMethodString(true, false, ""); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index cdfe71e11..7560c1283 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -10,8 +10,9 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 7; -const size_t COMPUTED_CONSTANT_COUNT = 200; +const size_t COMPUTED_CONSTANT_COUNT = 199; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "my_component"}; @@ -91,7 +92,6 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"eqnXorParenthesesRightRoot", "dimensionless", "my_component"}, {"eqnXorCoverageParentheses", "dimensionless", "my_component"}, {"eqnNot", "dimensionless", "my_component"}, - {"eqnPlus", "dimensionless", "my_component"}, {"eqnPlusMultiple", "dimensionless", "my_component"}, {"eqnPlusParentheses", "dimensionless", "my_component"}, {"eqnPlusUnary", "dimensionless", "my_component"}, @@ -237,6 +237,10 @@ const VariableInfo ALGEBRAIC_INFO[] = { {"eqnNlaVariable2", "dimensionless", "my_component"} }; +const VariableInfo EXTERNAL_INFO[] = { + {"eqnPlus", "dimensionless", "my_component"} +}; + double xor(double x, double y) { return (x != 0.0) ^ (y != 0.0); @@ -362,6 +366,17 @@ double * createAlgebraicArray() return res; } +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + void deleteArray(double *array) { free(array); @@ -374,6 +389,7 @@ typedef struct { double *constants; double *computedConstants; double *algebraic; + double *externals; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -392,7 +408,7 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[1] = u[1]; f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; - f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); + f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) @@ -419,18 +435,18 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[4] = 5.0; constants[5] = 6.0; constants[6] = 7.0; - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; + computedConstants[176] = 123.0; + computedConstants[177] = 123.456789; + computedConstants[178] = 123.0e99; + computedConstants[179] = 123.456789e99; + computedConstants[181] = 1.0; + computedConstants[182] = 0.0; + computedConstants[183] = 2.71828182845905; + computedConstants[184] = 3.14159265358979; + computedConstants[185] = INFINITY; + computedConstants[186] = NAN; + computedConstants[197] = 1.0; + computedConstants[198] = 3.0; algebraic[0] = 1.0; algebraic[1] = 2.0; } @@ -498,141 +514,141 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[58] = xor(constants[0] < constants[1], pow(constants[2], 1.0/constants[3])); computedConstants[59] = constants[0]/xor(constants[1], constants[2]); computedConstants[60] = !constants[0]; - computedConstants[61] = constants[0]+constants[1]; - computedConstants[62] = constants[0]+constants[1]+constants[2]; - computedConstants[63] = (constants[0] < constants[1])+(constants[2] > constants[3]); - computedConstants[64] = constants[0]; - computedConstants[65] = constants[0]-constants[1]; - computedConstants[66] = (constants[0] < constants[1])-(constants[2] > constants[3]); - computedConstants[67] = (constants[0] < constants[1])-(constants[2]+constants[3]); - computedConstants[68] = (constants[0] < constants[1])-constants[2]; - computedConstants[69] = constants[0]-(-constants[1]); - computedConstants[70] = constants[0]-(-constants[1]*constants[2]); - computedConstants[71] = -constants[0]; - computedConstants[72] = -(constants[0] < constants[1]); - computedConstants[73] = constants[0]*constants[1]; - computedConstants[74] = constants[0]*constants[1]*constants[2]; - computedConstants[75] = (constants[0] < constants[1])*(constants[2] > constants[3]); - computedConstants[76] = (constants[0]+constants[1])*(constants[2] > constants[3]); - computedConstants[77] = constants[0]*(constants[1] > constants[2]); - computedConstants[78] = (constants[0]-constants[1])*(constants[2] > constants[3]); - computedConstants[79] = -constants[0]*(constants[1] > constants[2]); - computedConstants[80] = (constants[0] < constants[1])*(constants[2]+constants[3]); - computedConstants[81] = (constants[0] < constants[1])*constants[2]; - computedConstants[82] = (constants[0] < constants[1])*(constants[2]-constants[3]); - computedConstants[83] = (constants[0] < constants[1])*-constants[2]; - computedConstants[84] = constants[0]/constants[1]; - computedConstants[85] = (constants[0] < constants[1])/(constants[3] > constants[2]); - computedConstants[86] = (constants[0]+constants[1])/(constants[3] > constants[2]); - computedConstants[87] = constants[0]/(constants[2] > constants[1]); - computedConstants[88] = (constants[0]-constants[1])/(constants[3] > constants[2]); - computedConstants[89] = -constants[0]/(constants[2] > constants[1]); - computedConstants[90] = (constants[0] < constants[1])/(constants[2]+constants[3]); - computedConstants[91] = (constants[0] < constants[1])/constants[2]; - computedConstants[92] = (constants[0] < constants[1])/(constants[2]-constants[3]); - computedConstants[93] = (constants[0] < constants[1])/-constants[2]; - computedConstants[94] = (constants[0] < constants[1])/(constants[2]*constants[3]); - computedConstants[95] = (constants[0] < constants[1])/(constants[2]/constants[3]); - computedConstants[96] = sqrt(constants[0]); - computedConstants[97] = pow(constants[0], 2.0); - computedConstants[98] = pow(constants[0], 3.0); - computedConstants[99] = pow(constants[0], constants[1]); - computedConstants[100] = pow(constants[0] <= constants[1], constants[2] >= constants[3]); - computedConstants[101] = pow(constants[0]+constants[1], constants[2] >= constants[3]); - computedConstants[102] = pow(constants[0], constants[1] >= constants[2]); - computedConstants[103] = pow(constants[0]-constants[1], constants[2] >= constants[3]); - computedConstants[104] = pow(-constants[0], constants[1] >= constants[2]); - computedConstants[105] = pow(constants[0]*constants[1], constants[2] >= constants[3]); - computedConstants[106] = pow(constants[0]/constants[1], constants[2] >= constants[3]); - computedConstants[107] = pow(constants[0] <= constants[1], constants[2]+constants[3]); - computedConstants[108] = pow(constants[0] <= constants[1], constants[2]); - computedConstants[109] = pow(constants[0] <= constants[1], constants[2]-constants[3]); - computedConstants[110] = pow(constants[0] <= constants[1], -constants[2]); - computedConstants[111] = pow(constants[0] <= constants[1], constants[2]*constants[3]); - computedConstants[112] = pow(constants[0] <= constants[1], constants[2]/constants[3]); - computedConstants[113] = pow(constants[0] <= constants[1], pow(constants[2], constants[3])); - computedConstants[114] = pow(constants[0] <= constants[1], pow(constants[2], 1.0/constants[3])); + computedConstants[61] = constants[0]+constants[1]+constants[2]; + computedConstants[62] = (constants[0] < constants[1])+(constants[2] > constants[3]); + computedConstants[63] = constants[0]; + computedConstants[64] = constants[0]-constants[1]; + computedConstants[65] = (constants[0] < constants[1])-(constants[2] > constants[3]); + computedConstants[66] = (constants[0] < constants[1])-(constants[2]+constants[3]); + computedConstants[67] = (constants[0] < constants[1])-constants[2]; + computedConstants[68] = constants[0]-(-constants[1]); + computedConstants[69] = constants[0]-(-constants[1]*constants[2]); + computedConstants[70] = -constants[0]; + computedConstants[71] = -(constants[0] < constants[1]); + computedConstants[72] = constants[0]*constants[1]; + computedConstants[73] = constants[0]*constants[1]*constants[2]; + computedConstants[74] = (constants[0] < constants[1])*(constants[2] > constants[3]); + computedConstants[75] = (constants[0]+constants[1])*(constants[2] > constants[3]); + computedConstants[76] = constants[0]*(constants[1] > constants[2]); + computedConstants[77] = (constants[0]-constants[1])*(constants[2] > constants[3]); + computedConstants[78] = -constants[0]*(constants[1] > constants[2]); + computedConstants[79] = (constants[0] < constants[1])*(constants[2]+constants[3]); + computedConstants[80] = (constants[0] < constants[1])*constants[2]; + computedConstants[81] = (constants[0] < constants[1])*(constants[2]-constants[3]); + computedConstants[82] = (constants[0] < constants[1])*-constants[2]; + computedConstants[83] = constants[0]/constants[1]; + computedConstants[84] = (constants[0] < constants[1])/(constants[3] > constants[2]); + computedConstants[85] = (constants[0]+constants[1])/(constants[3] > constants[2]); + computedConstants[86] = constants[0]/(constants[2] > constants[1]); + computedConstants[87] = (constants[0]-constants[1])/(constants[3] > constants[2]); + computedConstants[88] = -constants[0]/(constants[2] > constants[1]); + computedConstants[89] = (constants[0] < constants[1])/(constants[2]+constants[3]); + computedConstants[90] = (constants[0] < constants[1])/constants[2]; + computedConstants[91] = (constants[0] < constants[1])/(constants[2]-constants[3]); + computedConstants[92] = (constants[0] < constants[1])/-constants[2]; + computedConstants[93] = (constants[0] < constants[1])/(constants[2]*constants[3]); + computedConstants[94] = (constants[0] < constants[1])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[0]); + computedConstants[96] = pow(constants[0], 2.0); + computedConstants[97] = pow(constants[0], 3.0); + computedConstants[98] = pow(constants[0], constants[1]); + computedConstants[99] = pow(constants[0] <= constants[1], constants[2] >= constants[3]); + computedConstants[100] = pow(constants[0]+constants[1], constants[2] >= constants[3]); + computedConstants[101] = pow(constants[0], constants[1] >= constants[2]); + computedConstants[102] = pow(constants[0]-constants[1], constants[2] >= constants[3]); + computedConstants[103] = pow(-constants[0], constants[1] >= constants[2]); + computedConstants[104] = pow(constants[0]*constants[1], constants[2] >= constants[3]); + computedConstants[105] = pow(constants[0]/constants[1], constants[2] >= constants[3]); + computedConstants[106] = pow(constants[0] <= constants[1], constants[2]+constants[3]); + computedConstants[107] = pow(constants[0] <= constants[1], constants[2]); + computedConstants[108] = pow(constants[0] <= constants[1], constants[2]-constants[3]); + computedConstants[109] = pow(constants[0] <= constants[1], -constants[2]); + computedConstants[110] = pow(constants[0] <= constants[1], constants[2]*constants[3]); + computedConstants[111] = pow(constants[0] <= constants[1], constants[2]/constants[3]); + computedConstants[112] = pow(constants[0] <= constants[1], pow(constants[2], constants[3])); + computedConstants[113] = pow(constants[0] <= constants[1], pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[0]); computedConstants[115] = sqrt(constants[0]); - computedConstants[116] = sqrt(constants[0]); - computedConstants[117] = pow(constants[0], 1.0/3.0); - computedConstants[118] = pow(constants[0], 1.0/constants[1]); - computedConstants[119] = pow(constants[0] < constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[120] = pow(constants[0]+constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[121] = pow(constants[0], 1.0/(constants[2] > constants[1])); - computedConstants[122] = pow(constants[0]-constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[123] = pow(-constants[0], 1.0/(constants[2] > constants[1])); - computedConstants[124] = pow(constants[0]*constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[125] = pow(constants[0]/constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[126] = pow(constants[0] < constants[1], 1.0/(constants[2]+constants[3])); - computedConstants[127] = pow(constants[0] < constants[1], 1.0/constants[2]); - computedConstants[128] = pow(constants[0] < constants[1], 1.0/(constants[2]-constants[3])); - computedConstants[129] = pow(constants[0] < constants[1], 1.0/-constants[2]); - computedConstants[130] = pow(constants[0] < constants[1], 1.0/(constants[2]*constants[3])); - computedConstants[131] = pow(constants[0] < constants[1], 1.0/(constants[2]/constants[3])); - computedConstants[132] = pow(constants[0] < constants[1], 1.0/pow(constants[2], constants[3])); - computedConstants[133] = pow(constants[0] < constants[1], 1.0/pow(constants[2], 1.0/constants[3])); - computedConstants[134] = fabs(constants[0]); - computedConstants[135] = exp(constants[0]); - computedConstants[136] = log(constants[0]); - computedConstants[137] = log10(constants[0]); - computedConstants[138] = log(constants[0])/log(2.0); - computedConstants[139] = log10(constants[0]); - computedConstants[140] = log(constants[0])/log(constants[1]); - computedConstants[141] = ceil(constants[0]); - computedConstants[142] = floor(constants[0]); - computedConstants[143] = min(constants[0], constants[1]); - computedConstants[144] = min(constants[0], min(constants[1], constants[2])); - computedConstants[145] = max(constants[0], constants[1]); - computedConstants[146] = max(constants[0], max(constants[1], constants[2])); - computedConstants[147] = fmod(constants[0], constants[1]); - computedConstants[148] = sin(constants[0]); - computedConstants[149] = cos(constants[0]); - computedConstants[150] = tan(constants[0]); - computedConstants[151] = sec(constants[0]); - computedConstants[152] = csc(constants[0]); - computedConstants[153] = cot(constants[0]); - computedConstants[154] = sinh(constants[0]); - computedConstants[155] = cosh(constants[0]); - computedConstants[156] = tanh(constants[0]); - computedConstants[157] = sech(constants[0]); - computedConstants[158] = csch(constants[0]); - computedConstants[159] = coth(constants[0]); - computedConstants[160] = asin(constants[0]); - computedConstants[161] = acos(constants[0]); - computedConstants[162] = atan(constants[0]); - computedConstants[163] = asec(constants[0]); - computedConstants[164] = acsc(constants[0]); - computedConstants[165] = acot(constants[0]); - computedConstants[166] = asinh(constants[0]); - computedConstants[167] = acosh(constants[0]); - computedConstants[168] = atanh(constants[0]/2.0); - computedConstants[169] = asech(constants[0]); - computedConstants[170] = acsch(constants[0]); - computedConstants[171] = acoth(2.0*constants[0]); - computedConstants[172] = (constants[0] > constants[1])?constants[0]:NAN; - computedConstants[173] = (constants[0] > constants[1])?constants[0]:constants[2]; - computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; - computedConstants[175] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; - computedConstants[176] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); - computedConstants[181] = constants[0]; - computedConstants[188] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); - computedConstants[189] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); - computedConstants[190] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); - computedConstants[191] = (constants[0] && constants[1])/(((constants[2] > constants[3])?constants[1]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[1]:NAN))); - computedConstants[192] = (constants[0] || constants[1]) && xor(constants[0], constants[1]) && ((constants[2] > constants[3])?constants[1]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[1]:NAN) && xor(constants[0], constants[1]) && (constants[0] || constants[1]); - computedConstants[193] = (constants[0] && constants[1]) || xor(constants[0], constants[1]) || ((constants[2] > constants[3])?constants[1]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[1]:NAN) || xor(constants[0], constants[1]) || (constants[0] && constants[1]); - computedConstants[194] = xor(constants[0] && constants[1], xor(constants[0] || constants[1], xor((constants[2] > constants[3])?constants[1]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] || constants[1]), constants[0] && constants[1])))); - computedConstants[195] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); - computedConstants[196] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); - computedConstants[197] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); + computedConstants[116] = pow(constants[0], 1.0/3.0); + computedConstants[117] = pow(constants[0], 1.0/constants[1]); + computedConstants[118] = pow(constants[0] < constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[119] = pow(constants[0]+constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[120] = pow(constants[0], 1.0/(constants[2] > constants[1])); + computedConstants[121] = pow(constants[0]-constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[122] = pow(-constants[0], 1.0/(constants[2] > constants[1])); + computedConstants[123] = pow(constants[0]*constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[124] = pow(constants[0]/constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[125] = pow(constants[0] < constants[1], 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(constants[0] < constants[1], 1.0/constants[2]); + computedConstants[127] = pow(constants[0] < constants[1], 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(constants[0] < constants[1], 1.0/-constants[2]); + computedConstants[129] = pow(constants[0] < constants[1], 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(constants[0] < constants[1], 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(constants[0] < constants[1], 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(constants[0] < constants[1], 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[0]); + computedConstants[134] = exp(constants[0]); + computedConstants[135] = log(constants[0]); + computedConstants[136] = log10(constants[0]); + computedConstants[137] = log(constants[0])/log(2.0); + computedConstants[138] = log10(constants[0]); + computedConstants[139] = log(constants[0])/log(constants[1]); + computedConstants[140] = ceil(constants[0]); + computedConstants[141] = floor(constants[0]); + computedConstants[142] = min(constants[0], constants[1]); + computedConstants[143] = min(constants[0], min(constants[1], constants[2])); + computedConstants[144] = max(constants[0], constants[1]); + computedConstants[145] = max(constants[0], max(constants[1], constants[2])); + computedConstants[146] = fmod(constants[0], constants[1]); + computedConstants[147] = sin(constants[0]); + computedConstants[148] = cos(constants[0]); + computedConstants[149] = tan(constants[0]); + computedConstants[150] = sec(constants[0]); + computedConstants[151] = csc(constants[0]); + computedConstants[152] = cot(constants[0]); + computedConstants[153] = sinh(constants[0]); + computedConstants[154] = cosh(constants[0]); + computedConstants[155] = tanh(constants[0]); + computedConstants[156] = sech(constants[0]); + computedConstants[157] = csch(constants[0]); + computedConstants[158] = coth(constants[0]); + computedConstants[159] = asin(constants[0]); + computedConstants[160] = acos(constants[0]); + computedConstants[161] = atan(constants[0]); + computedConstants[162] = asec(constants[0]); + computedConstants[163] = acsc(constants[0]); + computedConstants[164] = acot(constants[0]); + computedConstants[165] = asinh(constants[0]); + computedConstants[166] = acosh(constants[0]); + computedConstants[167] = atanh(constants[0]/2.0); + computedConstants[168] = asech(constants[0]); + computedConstants[169] = acsch(constants[0]); + computedConstants[170] = acoth(2.0*constants[0]); + computedConstants[171] = (constants[0] > constants[1])?constants[0]:NAN; + computedConstants[172] = (constants[0] > constants[1])?constants[0]:constants[2]; + computedConstants[173] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; + computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; + computedConstants[175] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); + computedConstants[180] = constants[0]; + computedConstants[187] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[0] && constants[1])/(((constants[2] > constants[3])?constants[1]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[1]:NAN))); + computedConstants[191] = (constants[0] || constants[1]) && xor(constants[0], constants[1]) && ((constants[2] > constants[3])?constants[1]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[1]:NAN) && xor(constants[0], constants[1]) && (constants[0] || constants[1]); + computedConstants[192] = (constants[0] && constants[1]) || xor(constants[0], constants[1]) || ((constants[2] > constants[3])?constants[1]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[1]:NAN) || xor(constants[0], constants[1]) || (constants[0] && constants[1]); + computedConstants[193] = xor(constants[0] && constants[1], xor(constants[0] || constants[1], xor((constants[2] > constants[3])?constants[1]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] || constants[1]), constants[0] && constants[1])))); + computedConstants[194] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); + computedConstants[195] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); + computedConstants[196] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); findRoot0(voi, states, rates, constants, computedConstants, algebraic); } diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 8f8822482..e54a32cfa 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef struct { char name[38]; @@ -23,15 +24,19 @@ extern const VariableInfo STATE_INFO[]; extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); double * createAlgebraicArray(); +double * createExternalsArray(); void deleteArray(double *array); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); + void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index c969013df..3f78260f6 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -125,6 +125,17 @@ double * createAlgebraicArray() return res; } +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + void deleteArray(double *array) { free(array); @@ -137,6 +148,7 @@ typedef struct { double *constants; double *computedConstants; double *algebraic; + double *externals; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -155,7 +167,7 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[1] = u[1]; f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; - f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); + f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) @@ -182,18 +194,18 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[4] = 5.0; constants[5] = 6.0; constants[6] = 7.0; - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; + computedConstants[176] = 123.0; + computedConstants[177] = 123.456789; + computedConstants[178] = 123.0e99; + computedConstants[179] = 123.456789e99; + computedConstants[181] = 1.0; + computedConstants[182] = 0.0; + computedConstants[183] = 2.71828182845905; + computedConstants[184] = 3.14159265358979; + computedConstants[185] = INFINITY; + computedConstants[186] = NAN; + computedConstants[197] = 1.0; + computedConstants[198] = 3.0; algebraic[0] = 1.0; algebraic[1] = 2.0; } @@ -261,141 +273,141 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[58] = xor(lt(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])); computedConstants[59] = constants[0]/xor(constants[1], constants[2]); computedConstants[60] = not(constants[0]); - computedConstants[61] = constants[0]+constants[1]; - computedConstants[62] = constants[0]+constants[1]+constants[2]; - computedConstants[63] = lt(constants[0], constants[1])+gt(constants[2], constants[3]); - computedConstants[64] = constants[0]; - computedConstants[65] = constants[0]-constants[1]; - computedConstants[66] = lt(constants[0], constants[1])-gt(constants[2], constants[3]); - computedConstants[67] = lt(constants[0], constants[1])-(constants[2]+constants[3]); - computedConstants[68] = lt(constants[0], constants[1])-constants[2]; - computedConstants[69] = constants[0]-(-constants[1]); - computedConstants[70] = constants[0]-(-constants[1]*constants[2]); - computedConstants[71] = -constants[0]; - computedConstants[72] = -lt(constants[0], constants[1]); - computedConstants[73] = constants[0]*constants[1]; - computedConstants[74] = constants[0]*constants[1]*constants[2]; - computedConstants[75] = lt(constants[0], constants[1])*gt(constants[2], constants[3]); - computedConstants[76] = (constants[0]+constants[1])*gt(constants[2], constants[3]); - computedConstants[77] = constants[0]*gt(constants[1], constants[2]); - computedConstants[78] = (constants[0]-constants[1])*gt(constants[2], constants[3]); - computedConstants[79] = -constants[0]*gt(constants[1], constants[2]); - computedConstants[80] = lt(constants[0], constants[1])*(constants[2]+constants[3]); - computedConstants[81] = lt(constants[0], constants[1])*constants[2]; - computedConstants[82] = lt(constants[0], constants[1])*(constants[2]-constants[3]); - computedConstants[83] = lt(constants[0], constants[1])*-constants[2]; - computedConstants[84] = constants[0]/constants[1]; - computedConstants[85] = lt(constants[0], constants[1])/gt(constants[3], constants[2]); - computedConstants[86] = (constants[0]+constants[1])/gt(constants[3], constants[2]); - computedConstants[87] = constants[0]/gt(constants[2], constants[1]); - computedConstants[88] = (constants[0]-constants[1])/gt(constants[3], constants[2]); - computedConstants[89] = -constants[0]/gt(constants[2], constants[1]); - computedConstants[90] = lt(constants[0], constants[1])/(constants[2]+constants[3]); - computedConstants[91] = lt(constants[0], constants[1])/constants[2]; - computedConstants[92] = lt(constants[0], constants[1])/(constants[2]-constants[3]); - computedConstants[93] = lt(constants[0], constants[1])/-constants[2]; - computedConstants[94] = lt(constants[0], constants[1])/(constants[2]*constants[3]); - computedConstants[95] = lt(constants[0], constants[1])/(constants[2]/constants[3]); - computedConstants[96] = sqrt(constants[0]); - computedConstants[97] = pow(constants[0], 2.0); - computedConstants[98] = pow(constants[0], 3.0); - computedConstants[99] = pow(constants[0], constants[1]); - computedConstants[100] = pow(leq(constants[0], constants[1]), geq(constants[2], constants[3])); - computedConstants[101] = pow(constants[0]+constants[1], geq(constants[2], constants[3])); - computedConstants[102] = pow(constants[0], geq(constants[1], constants[2])); - computedConstants[103] = pow(constants[0]-constants[1], geq(constants[2], constants[3])); - computedConstants[104] = pow(-constants[0], geq(constants[1], constants[2])); - computedConstants[105] = pow(constants[0]*constants[1], geq(constants[2], constants[3])); - computedConstants[106] = pow(constants[0]/constants[1], geq(constants[2], constants[3])); - computedConstants[107] = pow(leq(constants[0], constants[1]), constants[2]+constants[3]); - computedConstants[108] = pow(leq(constants[0], constants[1]), constants[2]); - computedConstants[109] = pow(leq(constants[0], constants[1]), constants[2]-constants[3]); - computedConstants[110] = pow(leq(constants[0], constants[1]), -constants[2]); - computedConstants[111] = pow(leq(constants[0], constants[1]), constants[2]*constants[3]); - computedConstants[112] = pow(leq(constants[0], constants[1]), constants[2]/constants[3]); - computedConstants[113] = pow(leq(constants[0], constants[1]), pow(constants[2], constants[3])); - computedConstants[114] = pow(leq(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])); + computedConstants[61] = constants[0]+constants[1]+constants[2]; + computedConstants[62] = lt(constants[0], constants[1])+gt(constants[2], constants[3]); + computedConstants[63] = constants[0]; + computedConstants[64] = constants[0]-constants[1]; + computedConstants[65] = lt(constants[0], constants[1])-gt(constants[2], constants[3]); + computedConstants[66] = lt(constants[0], constants[1])-(constants[2]+constants[3]); + computedConstants[67] = lt(constants[0], constants[1])-constants[2]; + computedConstants[68] = constants[0]-(-constants[1]); + computedConstants[69] = constants[0]-(-constants[1]*constants[2]); + computedConstants[70] = -constants[0]; + computedConstants[71] = -lt(constants[0], constants[1]); + computedConstants[72] = constants[0]*constants[1]; + computedConstants[73] = constants[0]*constants[1]*constants[2]; + computedConstants[74] = lt(constants[0], constants[1])*gt(constants[2], constants[3]); + computedConstants[75] = (constants[0]+constants[1])*gt(constants[2], constants[3]); + computedConstants[76] = constants[0]*gt(constants[1], constants[2]); + computedConstants[77] = (constants[0]-constants[1])*gt(constants[2], constants[3]); + computedConstants[78] = -constants[0]*gt(constants[1], constants[2]); + computedConstants[79] = lt(constants[0], constants[1])*(constants[2]+constants[3]); + computedConstants[80] = lt(constants[0], constants[1])*constants[2]; + computedConstants[81] = lt(constants[0], constants[1])*(constants[2]-constants[3]); + computedConstants[82] = lt(constants[0], constants[1])*-constants[2]; + computedConstants[83] = constants[0]/constants[1]; + computedConstants[84] = lt(constants[0], constants[1])/gt(constants[3], constants[2]); + computedConstants[85] = (constants[0]+constants[1])/gt(constants[3], constants[2]); + computedConstants[86] = constants[0]/gt(constants[2], constants[1]); + computedConstants[87] = (constants[0]-constants[1])/gt(constants[3], constants[2]); + computedConstants[88] = -constants[0]/gt(constants[2], constants[1]); + computedConstants[89] = lt(constants[0], constants[1])/(constants[2]+constants[3]); + computedConstants[90] = lt(constants[0], constants[1])/constants[2]; + computedConstants[91] = lt(constants[0], constants[1])/(constants[2]-constants[3]); + computedConstants[92] = lt(constants[0], constants[1])/-constants[2]; + computedConstants[93] = lt(constants[0], constants[1])/(constants[2]*constants[3]); + computedConstants[94] = lt(constants[0], constants[1])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[0]); + computedConstants[96] = pow(constants[0], 2.0); + computedConstants[97] = pow(constants[0], 3.0); + computedConstants[98] = pow(constants[0], constants[1]); + computedConstants[99] = pow(leq(constants[0], constants[1]), geq(constants[2], constants[3])); + computedConstants[100] = pow(constants[0]+constants[1], geq(constants[2], constants[3])); + computedConstants[101] = pow(constants[0], geq(constants[1], constants[2])); + computedConstants[102] = pow(constants[0]-constants[1], geq(constants[2], constants[3])); + computedConstants[103] = pow(-constants[0], geq(constants[1], constants[2])); + computedConstants[104] = pow(constants[0]*constants[1], geq(constants[2], constants[3])); + computedConstants[105] = pow(constants[0]/constants[1], geq(constants[2], constants[3])); + computedConstants[106] = pow(leq(constants[0], constants[1]), constants[2]+constants[3]); + computedConstants[107] = pow(leq(constants[0], constants[1]), constants[2]); + computedConstants[108] = pow(leq(constants[0], constants[1]), constants[2]-constants[3]); + computedConstants[109] = pow(leq(constants[0], constants[1]), -constants[2]); + computedConstants[110] = pow(leq(constants[0], constants[1]), constants[2]*constants[3]); + computedConstants[111] = pow(leq(constants[0], constants[1]), constants[2]/constants[3]); + computedConstants[112] = pow(leq(constants[0], constants[1]), pow(constants[2], constants[3])); + computedConstants[113] = pow(leq(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[0]); computedConstants[115] = sqrt(constants[0]); - computedConstants[116] = sqrt(constants[0]); - computedConstants[117] = pow(constants[0], 1.0/3.0); - computedConstants[118] = pow(constants[0], 1.0/constants[1]); - computedConstants[119] = pow(lt(constants[0], constants[1]), 1.0/gt(constants[3], constants[2])); - computedConstants[120] = pow(constants[0]+constants[1], 1.0/gt(constants[3], constants[2])); - computedConstants[121] = pow(constants[0], 1.0/gt(constants[2], constants[1])); - computedConstants[122] = pow(constants[0]-constants[1], 1.0/gt(constants[3], constants[2])); - computedConstants[123] = pow(-constants[0], 1.0/gt(constants[2], constants[1])); - computedConstants[124] = pow(constants[0]*constants[1], 1.0/gt(constants[3], constants[2])); - computedConstants[125] = pow(constants[0]/constants[1], 1.0/gt(constants[3], constants[2])); - computedConstants[126] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]+constants[3])); - computedConstants[127] = pow(lt(constants[0], constants[1]), 1.0/constants[2]); - computedConstants[128] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]-constants[3])); - computedConstants[129] = pow(lt(constants[0], constants[1]), 1.0/-constants[2]); - computedConstants[130] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]*constants[3])); - computedConstants[131] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]/constants[3])); - computedConstants[132] = pow(lt(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])); - computedConstants[133] = pow(lt(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])); - computedConstants[134] = fabs(constants[0]); - computedConstants[135] = exp(constants[0]); - computedConstants[136] = log(constants[0]); - computedConstants[137] = log10(constants[0]); - computedConstants[138] = log(constants[0])/log(2.0); - computedConstants[139] = log10(constants[0]); - computedConstants[140] = log(constants[0])/log(constants[1]); - computedConstants[141] = ceil(constants[0]); - computedConstants[142] = floor(constants[0]); - computedConstants[143] = min(constants[0], constants[1]); - computedConstants[144] = min(constants[0], min(constants[1], constants[2])); - computedConstants[145] = max(constants[0], constants[1]); - computedConstants[146] = max(constants[0], max(constants[1], constants[2])); - computedConstants[147] = fmod(constants[0], constants[1]); - computedConstants[148] = sin(constants[0]); - computedConstants[149] = cos(constants[0]); - computedConstants[150] = tan(constants[0]); - computedConstants[151] = sec(constants[0]); - computedConstants[152] = csc(constants[0]); - computedConstants[153] = cot(constants[0]); - computedConstants[154] = sinh(constants[0]); - computedConstants[155] = cosh(constants[0]); - computedConstants[156] = tanh(constants[0]); - computedConstants[157] = sech(constants[0]); - computedConstants[158] = csch(constants[0]); - computedConstants[159] = coth(constants[0]); - computedConstants[160] = asin(constants[0]); - computedConstants[161] = acos(constants[0]); - computedConstants[162] = atan(constants[0]); - computedConstants[163] = asec(constants[0]); - computedConstants[164] = acsc(constants[0]); - computedConstants[165] = acot(constants[0]); - computedConstants[166] = asinh(constants[0]); - computedConstants[167] = acosh(constants[0]); - computedConstants[168] = atanh(constants[0]/2.0); - computedConstants[169] = asech(constants[0]); - computedConstants[170] = acsch(constants[0]); - computedConstants[171] = acoth(2.0*constants[0]); - computedConstants[172] = (gt(constants[0], constants[1]))?constants[0]:NAN; - computedConstants[173] = (gt(constants[0], constants[1]))?constants[0]:constants[2]; - computedConstants[174] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:NAN; - computedConstants[175] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:constants[6]; - computedConstants[176] = 123.0+((gt(constants[0], constants[1]))?constants[0]:NAN); - computedConstants[181] = constants[0]; - computedConstants[188] = and(constants[0], constants[1])+((gt(constants[2], constants[3]))?constants[1]:NAN)+constants[4]+and(constants[5], constants[6]); - computedConstants[189] = and(constants[0], constants[1])-(((gt(constants[2], constants[3]))?constants[1]:NAN)-(constants[4]-((gt(constants[2], constants[3]))?constants[1]:NAN)))-and(constants[5], constants[6]); - computedConstants[190] = and(constants[0], constants[1])*((gt(constants[2], constants[3]))?constants[1]:NAN)*constants[4]*((gt(constants[2], constants[3]))?constants[1]:NAN)*and(constants[5], constants[6]); - computedConstants[191] = and(constants[0], constants[1])/(((gt(constants[2], constants[3]))?constants[1]:NAN)/(constants[4]/((gt(constants[2], constants[3]))?constants[1]:NAN))); - computedConstants[192] = and(or(constants[0], constants[1]), and(xor(constants[0], constants[1]), and((gt(constants[2], constants[3]))?constants[1]:NAN, and(and(and(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), xor(constants[0], constants[1])), or(constants[0], constants[1]))))); - computedConstants[193] = or(and(constants[0], constants[1]), or(xor(constants[0], constants[1]), or((gt(constants[2], constants[3]))?constants[1]:NAN, or(or(or(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), xor(constants[0], constants[1])), and(constants[0], constants[1]))))); - computedConstants[194] = xor(and(constants[0], constants[1]), xor(or(constants[0], constants[1]), xor((gt(constants[2], constants[3]))?constants[1]:NAN, xor(xor(xor(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), or(constants[0], constants[1])), and(constants[0], constants[1]))))); - computedConstants[195] = pow(and(constants[0], constants[1]), pow((gt(constants[2], constants[3]))?constants[1]:NAN, pow(pow(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), and(constants[0], constants[1])))); - computedConstants[196] = pow(pow(pow(and(constants[0], constants[1]), 1.0/pow((gt(constants[2], constants[3]))?constants[1]:NAN, 1.0/constants[4])), 1.0/((gt(constants[2], constants[3]))?constants[1]:NAN)), 1.0/and(constants[0], constants[1])); - computedConstants[197] = -and(constants[0], constants[1])+-((gt(constants[2], constants[3]))?constants[1]:NAN); + computedConstants[116] = pow(constants[0], 1.0/3.0); + computedConstants[117] = pow(constants[0], 1.0/constants[1]); + computedConstants[118] = pow(lt(constants[0], constants[1]), 1.0/gt(constants[3], constants[2])); + computedConstants[119] = pow(constants[0]+constants[1], 1.0/gt(constants[3], constants[2])); + computedConstants[120] = pow(constants[0], 1.0/gt(constants[2], constants[1])); + computedConstants[121] = pow(constants[0]-constants[1], 1.0/gt(constants[3], constants[2])); + computedConstants[122] = pow(-constants[0], 1.0/gt(constants[2], constants[1])); + computedConstants[123] = pow(constants[0]*constants[1], 1.0/gt(constants[3], constants[2])); + computedConstants[124] = pow(constants[0]/constants[1], 1.0/gt(constants[3], constants[2])); + computedConstants[125] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(lt(constants[0], constants[1]), 1.0/constants[2]); + computedConstants[127] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(lt(constants[0], constants[1]), 1.0/-constants[2]); + computedConstants[129] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(lt(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(lt(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[0]); + computedConstants[134] = exp(constants[0]); + computedConstants[135] = log(constants[0]); + computedConstants[136] = log10(constants[0]); + computedConstants[137] = log(constants[0])/log(2.0); + computedConstants[138] = log10(constants[0]); + computedConstants[139] = log(constants[0])/log(constants[1]); + computedConstants[140] = ceil(constants[0]); + computedConstants[141] = floor(constants[0]); + computedConstants[142] = min(constants[0], constants[1]); + computedConstants[143] = min(constants[0], min(constants[1], constants[2])); + computedConstants[144] = max(constants[0], constants[1]); + computedConstants[145] = max(constants[0], max(constants[1], constants[2])); + computedConstants[146] = fmod(constants[0], constants[1]); + computedConstants[147] = sin(constants[0]); + computedConstants[148] = cos(constants[0]); + computedConstants[149] = tan(constants[0]); + computedConstants[150] = sec(constants[0]); + computedConstants[151] = csc(constants[0]); + computedConstants[152] = cot(constants[0]); + computedConstants[153] = sinh(constants[0]); + computedConstants[154] = cosh(constants[0]); + computedConstants[155] = tanh(constants[0]); + computedConstants[156] = sech(constants[0]); + computedConstants[157] = csch(constants[0]); + computedConstants[158] = coth(constants[0]); + computedConstants[159] = asin(constants[0]); + computedConstants[160] = acos(constants[0]); + computedConstants[161] = atan(constants[0]); + computedConstants[162] = asec(constants[0]); + computedConstants[163] = acsc(constants[0]); + computedConstants[164] = acot(constants[0]); + computedConstants[165] = asinh(constants[0]); + computedConstants[166] = acosh(constants[0]); + computedConstants[167] = atanh(constants[0]/2.0); + computedConstants[168] = asech(constants[0]); + computedConstants[169] = acsch(constants[0]); + computedConstants[170] = acoth(2.0*constants[0]); + computedConstants[171] = (gt(constants[0], constants[1]))?constants[0]:NAN; + computedConstants[172] = (gt(constants[0], constants[1]))?constants[0]:constants[2]; + computedConstants[173] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:NAN; + computedConstants[174] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:constants[6]; + computedConstants[175] = 123.0+((gt(constants[0], constants[1]))?constants[0]:NAN); + computedConstants[180] = constants[0]; + computedConstants[187] = and(constants[0], constants[1])+((gt(constants[2], constants[3]))?constants[1]:NAN)+constants[4]+and(constants[5], constants[6]); + computedConstants[188] = and(constants[0], constants[1])-(((gt(constants[2], constants[3]))?constants[1]:NAN)-(constants[4]-((gt(constants[2], constants[3]))?constants[1]:NAN)))-and(constants[5], constants[6]); + computedConstants[189] = and(constants[0], constants[1])*((gt(constants[2], constants[3]))?constants[1]:NAN)*constants[4]*((gt(constants[2], constants[3]))?constants[1]:NAN)*and(constants[5], constants[6]); + computedConstants[190] = and(constants[0], constants[1])/(((gt(constants[2], constants[3]))?constants[1]:NAN)/(constants[4]/((gt(constants[2], constants[3]))?constants[1]:NAN))); + computedConstants[191] = and(or(constants[0], constants[1]), and(xor(constants[0], constants[1]), and((gt(constants[2], constants[3]))?constants[1]:NAN, and(and(and(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), xor(constants[0], constants[1])), or(constants[0], constants[1]))))); + computedConstants[192] = or(and(constants[0], constants[1]), or(xor(constants[0], constants[1]), or((gt(constants[2], constants[3]))?constants[1]:NAN, or(or(or(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), xor(constants[0], constants[1])), and(constants[0], constants[1]))))); + computedConstants[193] = xor(and(constants[0], constants[1]), xor(or(constants[0], constants[1]), xor((gt(constants[2], constants[3]))?constants[1]:NAN, xor(xor(xor(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), or(constants[0], constants[1])), and(constants[0], constants[1]))))); + computedConstants[194] = pow(and(constants[0], constants[1]), pow((gt(constants[2], constants[3]))?constants[1]:NAN, pow(pow(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), and(constants[0], constants[1])))); + computedConstants[195] = pow(pow(pow(and(constants[0], constants[1]), 1.0/pow((gt(constants[2], constants[3]))?constants[1]:NAN, 1.0/constants[4])), 1.0/((gt(constants[2], constants[3]))?constants[1]:NAN)), 1.0/and(constants[0], constants[1])); + computedConstants[196] = -and(constants[0], constants[1])+-((gt(constants[2], constants[3]))?constants[1]:NAN); } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); findRoot0(voi, states, rates, constants, computedConstants, algebraic); } diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index a5fb08035..db42dd2a7 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -8,10 +8,13 @@ double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); double * createAlgebraicArray(); +double * createExternalsArray(); void deleteArray(double *array); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); + void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 5c6e1d9fd..a539d5704 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -10,8 +10,9 @@ const char LIBCELLML_VERSION[] = "0.5.0"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 7; -const size_t COMPUTED_CONSTANT_COUNT = 200; +const size_t COMPUTED_CONSTANT_COUNT = 199; const size_t ALGEBRAIC_COUNT = 2; +const size_t EXTERNAL_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "my_component"}; @@ -91,7 +92,6 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"eqnXorParenthesesRightRoot", "dimensionless", "my_component"}, {"eqnXorCoverageParentheses", "dimensionless", "my_component"}, {"eqnNot", "dimensionless", "my_component"}, - {"eqnPlus", "dimensionless", "my_component"}, {"eqnPlusMultiple", "dimensionless", "my_component"}, {"eqnPlusParentheses", "dimensionless", "my_component"}, {"eqnPlusUnary", "dimensionless", "my_component"}, @@ -237,6 +237,10 @@ const VariableInfo ALGEBRAIC_INFO[] = { {"eqnNlaVariable2", "dimensionless", "my_component"} }; +const VariableInfo EXTERNAL_INFO[] = { + {"eqnPlus", "dimensionless", "my_component"} +}; + double xor(double x, double y) { return (x != 0.0) ^ (y != 0.0); @@ -362,6 +366,17 @@ double * createAlgebraicArray() return res; } +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + void deleteArray(double *array) { free(array); @@ -374,6 +389,7 @@ typedef struct { double *constants; double *computedConstants; double *algebraic; + double *externals; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -392,7 +408,7 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[1] = u[1]; f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; - f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); + f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) @@ -419,18 +435,18 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[4] = 5.0; constants[5] = 6.0; constants[6] = 7.0; - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; + computedConstants[176] = 123.0; + computedConstants[177] = 123.456789; + computedConstants[178] = 123.0e99; + computedConstants[179] = 123.456789e99; + computedConstants[181] = 1.0; + computedConstants[182] = 0.0; + computedConstants[183] = 2.71828182845905; + computedConstants[184] = 3.14159265358979; + computedConstants[185] = INFINITY; + computedConstants[186] = NAN; + computedConstants[197] = 1.0; + computedConstants[198] = 3.0; algebraic[0] = 1.0; algebraic[1] = 2.0; } @@ -498,141 +514,141 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[58] = xor(constants[0] < constants[1], pow(constants[2], 1.0/constants[3])); computedConstants[59] = constants[0]/xor(constants[1], constants[2]); computedConstants[60] = !constants[0]; - computedConstants[61] = constants[0]+constants[1]; - computedConstants[62] = constants[0]+constants[1]+constants[2]; - computedConstants[63] = (constants[0] < constants[1])+(constants[2] > constants[3]); - computedConstants[64] = constants[0]; - computedConstants[65] = constants[0]-constants[1]; - computedConstants[66] = (constants[0] < constants[1])-(constants[2] > constants[3]); - computedConstants[67] = (constants[0] < constants[1])-(constants[2]+constants[3]); - computedConstants[68] = (constants[0] < constants[1])-constants[2]; - computedConstants[69] = constants[0]-(-constants[1]); - computedConstants[70] = constants[0]-(-constants[1]*constants[2]); - computedConstants[71] = -constants[0]; - computedConstants[72] = -(constants[0] < constants[1]); - computedConstants[73] = constants[0]*constants[1]; - computedConstants[74] = constants[0]*constants[1]*constants[2]; - computedConstants[75] = (constants[0] < constants[1])*(constants[2] > constants[3]); - computedConstants[76] = (constants[0]+constants[1])*(constants[2] > constants[3]); - computedConstants[77] = constants[0]*(constants[1] > constants[2]); - computedConstants[78] = (constants[0]-constants[1])*(constants[2] > constants[3]); - computedConstants[79] = -constants[0]*(constants[1] > constants[2]); - computedConstants[80] = (constants[0] < constants[1])*(constants[2]+constants[3]); - computedConstants[81] = (constants[0] < constants[1])*constants[2]; - computedConstants[82] = (constants[0] < constants[1])*(constants[2]-constants[3]); - computedConstants[83] = (constants[0] < constants[1])*-constants[2]; - computedConstants[84] = constants[0]/constants[1]; - computedConstants[85] = (constants[0] < constants[1])/(constants[3] > constants[2]); - computedConstants[86] = (constants[0]+constants[1])/(constants[3] > constants[2]); - computedConstants[87] = constants[0]/(constants[2] > constants[1]); - computedConstants[88] = (constants[0]-constants[1])/(constants[3] > constants[2]); - computedConstants[89] = -constants[0]/(constants[2] > constants[1]); - computedConstants[90] = (constants[0] < constants[1])/(constants[2]+constants[3]); - computedConstants[91] = (constants[0] < constants[1])/constants[2]; - computedConstants[92] = (constants[0] < constants[1])/(constants[2]-constants[3]); - computedConstants[93] = (constants[0] < constants[1])/-constants[2]; - computedConstants[94] = (constants[0] < constants[1])/(constants[2]*constants[3]); - computedConstants[95] = (constants[0] < constants[1])/(constants[2]/constants[3]); - computedConstants[96] = sqrt(constants[0]); - computedConstants[97] = pow(constants[0], 2.0); - computedConstants[98] = pow(constants[0], 3.0); - computedConstants[99] = pow(constants[0], constants[1]); - computedConstants[100] = pow(constants[0] <= constants[1], constants[2] >= constants[3]); - computedConstants[101] = pow(constants[0]+constants[1], constants[2] >= constants[3]); - computedConstants[102] = pow(constants[0], constants[1] >= constants[2]); - computedConstants[103] = pow(constants[0]-constants[1], constants[2] >= constants[3]); - computedConstants[104] = pow(-constants[0], constants[1] >= constants[2]); - computedConstants[105] = pow(constants[0]*constants[1], constants[2] >= constants[3]); - computedConstants[106] = pow(constants[0]/constants[1], constants[2] >= constants[3]); - computedConstants[107] = pow(constants[0] <= constants[1], constants[2]+constants[3]); - computedConstants[108] = pow(constants[0] <= constants[1], constants[2]); - computedConstants[109] = pow(constants[0] <= constants[1], constants[2]-constants[3]); - computedConstants[110] = pow(constants[0] <= constants[1], -constants[2]); - computedConstants[111] = pow(constants[0] <= constants[1], constants[2]*constants[3]); - computedConstants[112] = pow(constants[0] <= constants[1], constants[2]/constants[3]); - computedConstants[113] = pow(constants[0] <= constants[1], pow(constants[2], constants[3])); - computedConstants[114] = pow(constants[0] <= constants[1], pow(constants[2], 1.0/constants[3])); + computedConstants[61] = constants[0]+constants[1]+constants[2]; + computedConstants[62] = (constants[0] < constants[1])+(constants[2] > constants[3]); + computedConstants[63] = constants[0]; + computedConstants[64] = constants[0]-constants[1]; + computedConstants[65] = (constants[0] < constants[1])-(constants[2] > constants[3]); + computedConstants[66] = (constants[0] < constants[1])-(constants[2]+constants[3]); + computedConstants[67] = (constants[0] < constants[1])-constants[2]; + computedConstants[68] = constants[0]-(-constants[1]); + computedConstants[69] = constants[0]-(-constants[1]*constants[2]); + computedConstants[70] = -constants[0]; + computedConstants[71] = -(constants[0] < constants[1]); + computedConstants[72] = constants[0]*constants[1]; + computedConstants[73] = constants[0]*constants[1]*constants[2]; + computedConstants[74] = (constants[0] < constants[1])*(constants[2] > constants[3]); + computedConstants[75] = (constants[0]+constants[1])*(constants[2] > constants[3]); + computedConstants[76] = constants[0]*(constants[1] > constants[2]); + computedConstants[77] = (constants[0]-constants[1])*(constants[2] > constants[3]); + computedConstants[78] = -constants[0]*(constants[1] > constants[2]); + computedConstants[79] = (constants[0] < constants[1])*(constants[2]+constants[3]); + computedConstants[80] = (constants[0] < constants[1])*constants[2]; + computedConstants[81] = (constants[0] < constants[1])*(constants[2]-constants[3]); + computedConstants[82] = (constants[0] < constants[1])*-constants[2]; + computedConstants[83] = constants[0]/constants[1]; + computedConstants[84] = (constants[0] < constants[1])/(constants[3] > constants[2]); + computedConstants[85] = (constants[0]+constants[1])/(constants[3] > constants[2]); + computedConstants[86] = constants[0]/(constants[2] > constants[1]); + computedConstants[87] = (constants[0]-constants[1])/(constants[3] > constants[2]); + computedConstants[88] = -constants[0]/(constants[2] > constants[1]); + computedConstants[89] = (constants[0] < constants[1])/(constants[2]+constants[3]); + computedConstants[90] = (constants[0] < constants[1])/constants[2]; + computedConstants[91] = (constants[0] < constants[1])/(constants[2]-constants[3]); + computedConstants[92] = (constants[0] < constants[1])/-constants[2]; + computedConstants[93] = (constants[0] < constants[1])/(constants[2]*constants[3]); + computedConstants[94] = (constants[0] < constants[1])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[0]); + computedConstants[96] = pow(constants[0], 2.0); + computedConstants[97] = pow(constants[0], 3.0); + computedConstants[98] = pow(constants[0], constants[1]); + computedConstants[99] = pow(constants[0] <= constants[1], constants[2] >= constants[3]); + computedConstants[100] = pow(constants[0]+constants[1], constants[2] >= constants[3]); + computedConstants[101] = pow(constants[0], constants[1] >= constants[2]); + computedConstants[102] = pow(constants[0]-constants[1], constants[2] >= constants[3]); + computedConstants[103] = pow(-constants[0], constants[1] >= constants[2]); + computedConstants[104] = pow(constants[0]*constants[1], constants[2] >= constants[3]); + computedConstants[105] = pow(constants[0]/constants[1], constants[2] >= constants[3]); + computedConstants[106] = pow(constants[0] <= constants[1], constants[2]+constants[3]); + computedConstants[107] = pow(constants[0] <= constants[1], constants[2]); + computedConstants[108] = pow(constants[0] <= constants[1], constants[2]-constants[3]); + computedConstants[109] = pow(constants[0] <= constants[1], -constants[2]); + computedConstants[110] = pow(constants[0] <= constants[1], constants[2]*constants[3]); + computedConstants[111] = pow(constants[0] <= constants[1], constants[2]/constants[3]); + computedConstants[112] = pow(constants[0] <= constants[1], pow(constants[2], constants[3])); + computedConstants[113] = pow(constants[0] <= constants[1], pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[0]); computedConstants[115] = sqrt(constants[0]); - computedConstants[116] = sqrt(constants[0]); - computedConstants[117] = pow(constants[0], 1.0/3.0); - computedConstants[118] = pow(constants[0], 1.0/constants[1]); - computedConstants[119] = pow(constants[0] < constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[120] = pow(constants[0]+constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[121] = pow(constants[0], 1.0/(constants[2] > constants[1])); - computedConstants[122] = pow(constants[0]-constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[123] = pow(-constants[0], 1.0/(constants[2] > constants[1])); - computedConstants[124] = pow(constants[0]*constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[125] = pow(constants[0]/constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[126] = pow(constants[0] < constants[1], 1.0/(constants[2]+constants[3])); - computedConstants[127] = pow(constants[0] < constants[1], 1.0/constants[2]); - computedConstants[128] = pow(constants[0] < constants[1], 1.0/(constants[2]-constants[3])); - computedConstants[129] = pow(constants[0] < constants[1], 1.0/-constants[2]); - computedConstants[130] = pow(constants[0] < constants[1], 1.0/(constants[2]*constants[3])); - computedConstants[131] = pow(constants[0] < constants[1], 1.0/(constants[2]/constants[3])); - computedConstants[132] = pow(constants[0] < constants[1], 1.0/pow(constants[2], constants[3])); - computedConstants[133] = pow(constants[0] < constants[1], 1.0/pow(constants[2], 1.0/constants[3])); - computedConstants[134] = fabs(constants[0]); - computedConstants[135] = exp(constants[0]); - computedConstants[136] = log(constants[0]); - computedConstants[137] = log10(constants[0]); - computedConstants[138] = log(constants[0])/log(2.0); - computedConstants[139] = log10(constants[0]); - computedConstants[140] = log(constants[0])/log(constants[1]); - computedConstants[141] = ceil(constants[0]); - computedConstants[142] = floor(constants[0]); - computedConstants[143] = min(constants[0], constants[1]); - computedConstants[144] = min(constants[0], min(constants[1], constants[2])); - computedConstants[145] = max(constants[0], constants[1]); - computedConstants[146] = max(constants[0], max(constants[1], constants[2])); - computedConstants[147] = fmod(constants[0], constants[1]); - computedConstants[148] = sin(constants[0]); - computedConstants[149] = cos(constants[0]); - computedConstants[150] = tan(constants[0]); - computedConstants[151] = sec(constants[0]); - computedConstants[152] = csc(constants[0]); - computedConstants[153] = cot(constants[0]); - computedConstants[154] = sinh(constants[0]); - computedConstants[155] = cosh(constants[0]); - computedConstants[156] = tanh(constants[0]); - computedConstants[157] = sech(constants[0]); - computedConstants[158] = csch(constants[0]); - computedConstants[159] = coth(constants[0]); - computedConstants[160] = asin(constants[0]); - computedConstants[161] = acos(constants[0]); - computedConstants[162] = atan(constants[0]); - computedConstants[163] = asec(constants[0]); - computedConstants[164] = acsc(constants[0]); - computedConstants[165] = acot(constants[0]); - computedConstants[166] = asinh(constants[0]); - computedConstants[167] = acosh(constants[0]); - computedConstants[168] = atanh(constants[0]/2.0); - computedConstants[169] = asech(constants[0]); - computedConstants[170] = acsch(constants[0]); - computedConstants[171] = acoth(2.0*constants[0]); - computedConstants[172] = (constants[0] > constants[1])?constants[0]:NAN; - computedConstants[173] = (constants[0] > constants[1])?constants[0]:constants[2]; - computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; - computedConstants[175] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; - computedConstants[176] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); - computedConstants[181] = constants[0]; - computedConstants[188] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); - computedConstants[189] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); - computedConstants[190] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); - computedConstants[191] = (constants[0] && constants[1])/(((constants[2] > constants[3])?constants[1]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[1]:NAN))); - computedConstants[192] = (constants[0] || constants[1]) && xor(constants[0], constants[1]) && ((constants[2] > constants[3])?constants[1]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[1]:NAN) && xor(constants[0], constants[1]) && (constants[0] || constants[1]); - computedConstants[193] = (constants[0] && constants[1]) || xor(constants[0], constants[1]) || ((constants[2] > constants[3])?constants[1]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[1]:NAN) || xor(constants[0], constants[1]) || (constants[0] && constants[1]); - computedConstants[194] = xor(constants[0] && constants[1], xor(constants[0] || constants[1], xor((constants[2] > constants[3])?constants[1]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] || constants[1]), constants[0] && constants[1])))); - computedConstants[195] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); - computedConstants[196] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); - computedConstants[197] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); + computedConstants[116] = pow(constants[0], 1.0/3.0); + computedConstants[117] = pow(constants[0], 1.0/constants[1]); + computedConstants[118] = pow(constants[0] < constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[119] = pow(constants[0]+constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[120] = pow(constants[0], 1.0/(constants[2] > constants[1])); + computedConstants[121] = pow(constants[0]-constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[122] = pow(-constants[0], 1.0/(constants[2] > constants[1])); + computedConstants[123] = pow(constants[0]*constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[124] = pow(constants[0]/constants[1], 1.0/(constants[3] > constants[2])); + computedConstants[125] = pow(constants[0] < constants[1], 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(constants[0] < constants[1], 1.0/constants[2]); + computedConstants[127] = pow(constants[0] < constants[1], 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(constants[0] < constants[1], 1.0/-constants[2]); + computedConstants[129] = pow(constants[0] < constants[1], 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(constants[0] < constants[1], 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(constants[0] < constants[1], 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(constants[0] < constants[1], 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[0]); + computedConstants[134] = exp(constants[0]); + computedConstants[135] = log(constants[0]); + computedConstants[136] = log10(constants[0]); + computedConstants[137] = log(constants[0])/log(2.0); + computedConstants[138] = log10(constants[0]); + computedConstants[139] = log(constants[0])/log(constants[1]); + computedConstants[140] = ceil(constants[0]); + computedConstants[141] = floor(constants[0]); + computedConstants[142] = min(constants[0], constants[1]); + computedConstants[143] = min(constants[0], min(constants[1], constants[2])); + computedConstants[144] = max(constants[0], constants[1]); + computedConstants[145] = max(constants[0], max(constants[1], constants[2])); + computedConstants[146] = fmod(constants[0], constants[1]); + computedConstants[147] = sin(constants[0]); + computedConstants[148] = cos(constants[0]); + computedConstants[149] = tan(constants[0]); + computedConstants[150] = sec(constants[0]); + computedConstants[151] = csc(constants[0]); + computedConstants[152] = cot(constants[0]); + computedConstants[153] = sinh(constants[0]); + computedConstants[154] = cosh(constants[0]); + computedConstants[155] = tanh(constants[0]); + computedConstants[156] = sech(constants[0]); + computedConstants[157] = csch(constants[0]); + computedConstants[158] = coth(constants[0]); + computedConstants[159] = asin(constants[0]); + computedConstants[160] = acos(constants[0]); + computedConstants[161] = atan(constants[0]); + computedConstants[162] = asec(constants[0]); + computedConstants[163] = acsc(constants[0]); + computedConstants[164] = acot(constants[0]); + computedConstants[165] = asinh(constants[0]); + computedConstants[166] = acosh(constants[0]); + computedConstants[167] = atanh(constants[0]/2.0); + computedConstants[168] = asech(constants[0]); + computedConstants[169] = acsch(constants[0]); + computedConstants[170] = acoth(2.0*constants[0]); + computedConstants[171] = (constants[0] > constants[1])?constants[0]:NAN; + computedConstants[172] = (constants[0] > constants[1])?constants[0]:constants[2]; + computedConstants[173] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; + computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; + computedConstants[175] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); + computedConstants[180] = constants[0]; + computedConstants[187] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[0] && constants[1])/(((constants[2] > constants[3])?constants[1]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[1]:NAN))); + computedConstants[191] = (constants[0] || constants[1]) && xor(constants[0], constants[1]) && ((constants[2] > constants[3])?constants[1]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[1]:NAN) && xor(constants[0], constants[1]) && (constants[0] || constants[1]); + computedConstants[192] = (constants[0] && constants[1]) || xor(constants[0], constants[1]) || ((constants[2] > constants[3])?constants[1]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[1]:NAN) || xor(constants[0], constants[1]) || (constants[0] && constants[1]); + computedConstants[193] = xor(constants[0] && constants[1], xor(constants[0] || constants[1], xor((constants[2] > constants[3])?constants[1]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] || constants[1]), constants[0] && constants[1])))); + computedConstants[194] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); + computedConstants[195] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); + computedConstants[196] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); findRoot0(voi, states, rates, constants, computedConstants, algebraic); } diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index df9429751..1f4d048d6 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -11,6 +11,7 @@ extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; typedef struct { char name[38]; @@ -23,15 +24,19 @@ extern const VariableInfo STATE_INFO[]; extern const VariableInfo CONSTANT_INFO[]; extern const VariableInfo COMPUTED_CONSTANT_INFO[]; extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; double * createStatesVector(); double * createConstantsArray(); double * createComputedConstantsArray(); double * createAlgebraicArray(); +double * createExternalsArray(); void deleteArray(double *array); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); + void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 4c224613d..a953afffa 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -9,8 +9,9 @@ STATE_COUNT = 1 CONSTANT_COUNT = 7 -COMPUTED_CONSTANT_COUNT = 200 +COMPUTED_CONSTANT_COUNT = 199 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 1 VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} @@ -90,7 +91,6 @@ {"name": "eqnXorParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, {"name": "eqnXorCoverageParentheses", "units": "dimensionless", "component": "my_component"}, {"name": "eqnNot", "units": "dimensionless", "component": "my_component"}, - {"name": "eqnPlus", "units": "dimensionless", "component": "my_component"}, {"name": "eqnPlusMultiple", "units": "dimensionless", "component": "my_component"}, {"name": "eqnPlusParentheses", "units": "dimensionless", "component": "my_component"}, {"name": "eqnPlusUnary", "units": "dimensionless", "component": "my_component"}, @@ -236,6 +236,10 @@ {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"} ] +EXTERNAL_INFO = [ + {"name": "eqnPlus", "units": "dimensionless", "component": "my_component"} +] + def eq_func(x, y): return 1.0 if x == y else 0.0 @@ -355,6 +359,10 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT +def create_externals_array(): + return [nan]*EXTERNAL_COUNT + + from nlasolver import nla_solve @@ -370,7 +378,7 @@ def objective_function_0(u, f, data): algebraic[1] = u[1] f[0] = algebraic[0]+algebraic[1]+states[0]-0.0 - f[1] = algebraic[0]-algebraic[1]-(computed_constants[198]+computed_constants[199]) + f[1] = algebraic[0]-algebraic[1]-(computed_constants[197]+computed_constants[198]) def find_root_0(voi, states, rates, constants, computed_constants, algebraic): @@ -394,18 +402,18 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic constants[4] = 5.0 constants[5] = 6.0 constants[6] = 7.0 - computed_constants[177] = 123.0 - computed_constants[178] = 123.456789 - computed_constants[179] = 123.0e99 - computed_constants[180] = 123.456789e99 - computed_constants[182] = 1.0 - computed_constants[183] = 0.0 - computed_constants[184] = 2.71828182845905 - computed_constants[185] = 3.14159265358979 - computed_constants[186] = inf - computed_constants[187] = nan - computed_constants[198] = 1.0 - computed_constants[199] = 3.0 + computed_constants[176] = 123.0 + computed_constants[177] = 123.456789 + computed_constants[178] = 123.0e99 + computed_constants[179] = 123.456789e99 + computed_constants[181] = 1.0 + computed_constants[182] = 0.0 + computed_constants[183] = 2.71828182845905 + computed_constants[184] = 3.14159265358979 + computed_constants[185] = inf + computed_constants[186] = nan + computed_constants[197] = 1.0 + computed_constants[198] = 3.0 algebraic[0] = 1.0 algebraic[1] = 2.0 @@ -472,138 +480,138 @@ def compute_computed_constants(constants, computed_constants): computed_constants[58] = xor_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) computed_constants[59] = constants[0]/xor_func(constants[1], constants[2]) computed_constants[60] = not_func(constants[0]) - computed_constants[61] = constants[0]+constants[1] - computed_constants[62] = constants[0]+constants[1]+constants[2] - computed_constants[63] = lt_func(constants[0], constants[1])+gt_func(constants[2], constants[3]) - computed_constants[64] = constants[0] - computed_constants[65] = constants[0]-constants[1] - computed_constants[66] = lt_func(constants[0], constants[1])-gt_func(constants[2], constants[3]) - computed_constants[67] = lt_func(constants[0], constants[1])-(constants[2]+constants[3]) - computed_constants[68] = lt_func(constants[0], constants[1])-constants[2] - computed_constants[69] = constants[0]-(-constants[1]) - computed_constants[70] = constants[0]-(-constants[1]*constants[2]) - computed_constants[71] = -constants[0] - computed_constants[72] = -lt_func(constants[0], constants[1]) - computed_constants[73] = constants[0]*constants[1] - computed_constants[74] = constants[0]*constants[1]*constants[2] - computed_constants[75] = lt_func(constants[0], constants[1])*gt_func(constants[2], constants[3]) - computed_constants[76] = (constants[0]+constants[1])*gt_func(constants[2], constants[3]) - computed_constants[77] = constants[0]*gt_func(constants[1], constants[2]) - computed_constants[78] = (constants[0]-constants[1])*gt_func(constants[2], constants[3]) - computed_constants[79] = -constants[0]*gt_func(constants[1], constants[2]) - computed_constants[80] = lt_func(constants[0], constants[1])*(constants[2]+constants[3]) - computed_constants[81] = lt_func(constants[0], constants[1])*constants[2] - computed_constants[82] = lt_func(constants[0], constants[1])*(constants[2]-constants[3]) - computed_constants[83] = lt_func(constants[0], constants[1])*-constants[2] - computed_constants[84] = constants[0]/constants[1] - computed_constants[85] = lt_func(constants[0], constants[1])/gt_func(constants[3], constants[2]) - computed_constants[86] = (constants[0]+constants[1])/gt_func(constants[3], constants[2]) - computed_constants[87] = constants[0]/gt_func(constants[2], constants[1]) - computed_constants[88] = (constants[0]-constants[1])/gt_func(constants[3], constants[2]) - computed_constants[89] = -constants[0]/gt_func(constants[2], constants[1]) - computed_constants[90] = lt_func(constants[0], constants[1])/(constants[2]+constants[3]) - computed_constants[91] = lt_func(constants[0], constants[1])/constants[2] - computed_constants[92] = lt_func(constants[0], constants[1])/(constants[2]-constants[3]) - computed_constants[93] = lt_func(constants[0], constants[1])/-constants[2] - computed_constants[94] = lt_func(constants[0], constants[1])/(constants[2]*constants[3]) - computed_constants[95] = lt_func(constants[0], constants[1])/(constants[2]/constants[3]) - computed_constants[96] = sqrt(constants[0]) - computed_constants[97] = pow(constants[0], 2.0) - computed_constants[98] = pow(constants[0], 3.0) - computed_constants[99] = pow(constants[0], constants[1]) - computed_constants[100] = pow(leq_func(constants[0], constants[1]), geq_func(constants[2], constants[3])) - computed_constants[101] = pow(constants[0]+constants[1], geq_func(constants[2], constants[3])) - computed_constants[102] = pow(constants[0], geq_func(constants[1], constants[2])) - computed_constants[103] = pow(constants[0]-constants[1], geq_func(constants[2], constants[3])) - computed_constants[104] = pow(-constants[0], geq_func(constants[1], constants[2])) - computed_constants[105] = pow(constants[0]*constants[1], geq_func(constants[2], constants[3])) - computed_constants[106] = pow(constants[0]/constants[1], geq_func(constants[2], constants[3])) - computed_constants[107] = pow(leq_func(constants[0], constants[1]), constants[2]+constants[3]) - computed_constants[108] = pow(leq_func(constants[0], constants[1]), constants[2]) - computed_constants[109] = pow(leq_func(constants[0], constants[1]), constants[2]-constants[3]) - computed_constants[110] = pow(leq_func(constants[0], constants[1]), -constants[2]) - computed_constants[111] = pow(leq_func(constants[0], constants[1]), constants[2]*constants[3]) - computed_constants[112] = pow(leq_func(constants[0], constants[1]), constants[2]/constants[3]) - computed_constants[113] = pow(leq_func(constants[0], constants[1]), pow(constants[2], constants[3])) - computed_constants[114] = pow(leq_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[61] = constants[0]+constants[1]+constants[2] + computed_constants[62] = lt_func(constants[0], constants[1])+gt_func(constants[2], constants[3]) + computed_constants[63] = constants[0] + computed_constants[64] = constants[0]-constants[1] + computed_constants[65] = lt_func(constants[0], constants[1])-gt_func(constants[2], constants[3]) + computed_constants[66] = lt_func(constants[0], constants[1])-(constants[2]+constants[3]) + computed_constants[67] = lt_func(constants[0], constants[1])-constants[2] + computed_constants[68] = constants[0]-(-constants[1]) + computed_constants[69] = constants[0]-(-constants[1]*constants[2]) + computed_constants[70] = -constants[0] + computed_constants[71] = -lt_func(constants[0], constants[1]) + computed_constants[72] = constants[0]*constants[1] + computed_constants[73] = constants[0]*constants[1]*constants[2] + computed_constants[74] = lt_func(constants[0], constants[1])*gt_func(constants[2], constants[3]) + computed_constants[75] = (constants[0]+constants[1])*gt_func(constants[2], constants[3]) + computed_constants[76] = constants[0]*gt_func(constants[1], constants[2]) + computed_constants[77] = (constants[0]-constants[1])*gt_func(constants[2], constants[3]) + computed_constants[78] = -constants[0]*gt_func(constants[1], constants[2]) + computed_constants[79] = lt_func(constants[0], constants[1])*(constants[2]+constants[3]) + computed_constants[80] = lt_func(constants[0], constants[1])*constants[2] + computed_constants[81] = lt_func(constants[0], constants[1])*(constants[2]-constants[3]) + computed_constants[82] = lt_func(constants[0], constants[1])*-constants[2] + computed_constants[83] = constants[0]/constants[1] + computed_constants[84] = lt_func(constants[0], constants[1])/gt_func(constants[3], constants[2]) + computed_constants[85] = (constants[0]+constants[1])/gt_func(constants[3], constants[2]) + computed_constants[86] = constants[0]/gt_func(constants[2], constants[1]) + computed_constants[87] = (constants[0]-constants[1])/gt_func(constants[3], constants[2]) + computed_constants[88] = -constants[0]/gt_func(constants[2], constants[1]) + computed_constants[89] = lt_func(constants[0], constants[1])/(constants[2]+constants[3]) + computed_constants[90] = lt_func(constants[0], constants[1])/constants[2] + computed_constants[91] = lt_func(constants[0], constants[1])/(constants[2]-constants[3]) + computed_constants[92] = lt_func(constants[0], constants[1])/-constants[2] + computed_constants[93] = lt_func(constants[0], constants[1])/(constants[2]*constants[3]) + computed_constants[94] = lt_func(constants[0], constants[1])/(constants[2]/constants[3]) + computed_constants[95] = sqrt(constants[0]) + computed_constants[96] = pow(constants[0], 2.0) + computed_constants[97] = pow(constants[0], 3.0) + computed_constants[98] = pow(constants[0], constants[1]) + computed_constants[99] = pow(leq_func(constants[0], constants[1]), geq_func(constants[2], constants[3])) + computed_constants[100] = pow(constants[0]+constants[1], geq_func(constants[2], constants[3])) + computed_constants[101] = pow(constants[0], geq_func(constants[1], constants[2])) + computed_constants[102] = pow(constants[0]-constants[1], geq_func(constants[2], constants[3])) + computed_constants[103] = pow(-constants[0], geq_func(constants[1], constants[2])) + computed_constants[104] = pow(constants[0]*constants[1], geq_func(constants[2], constants[3])) + computed_constants[105] = pow(constants[0]/constants[1], geq_func(constants[2], constants[3])) + computed_constants[106] = pow(leq_func(constants[0], constants[1]), constants[2]+constants[3]) + computed_constants[107] = pow(leq_func(constants[0], constants[1]), constants[2]) + computed_constants[108] = pow(leq_func(constants[0], constants[1]), constants[2]-constants[3]) + computed_constants[109] = pow(leq_func(constants[0], constants[1]), -constants[2]) + computed_constants[110] = pow(leq_func(constants[0], constants[1]), constants[2]*constants[3]) + computed_constants[111] = pow(leq_func(constants[0], constants[1]), constants[2]/constants[3]) + computed_constants[112] = pow(leq_func(constants[0], constants[1]), pow(constants[2], constants[3])) + computed_constants[113] = pow(leq_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[114] = sqrt(constants[0]) computed_constants[115] = sqrt(constants[0]) - computed_constants[116] = sqrt(constants[0]) - computed_constants[117] = pow(constants[0], 1.0/3.0) - computed_constants[118] = pow(constants[0], 1.0/constants[1]) - computed_constants[119] = pow(lt_func(constants[0], constants[1]), 1.0/gt_func(constants[3], constants[2])) - computed_constants[120] = pow(constants[0]+constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[121] = pow(constants[0], 1.0/gt_func(constants[2], constants[1])) - computed_constants[122] = pow(constants[0]-constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[123] = pow(-constants[0], 1.0/gt_func(constants[2], constants[1])) - computed_constants[124] = pow(constants[0]*constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[125] = pow(constants[0]/constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[126] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]+constants[3])) - computed_constants[127] = pow(lt_func(constants[0], constants[1]), 1.0/constants[2]) - computed_constants[128] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]-constants[3])) - computed_constants[129] = pow(lt_func(constants[0], constants[1]), 1.0/-constants[2]) - computed_constants[130] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]*constants[3])) - computed_constants[131] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]/constants[3])) - computed_constants[132] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])) - computed_constants[133] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])) - computed_constants[134] = fabs(constants[0]) - computed_constants[135] = exp(constants[0]) - computed_constants[136] = log(constants[0]) - computed_constants[137] = log10(constants[0]) - computed_constants[138] = log(constants[0])/log(2.0) - computed_constants[139] = log10(constants[0]) - computed_constants[140] = log(constants[0])/log(constants[1]) - computed_constants[141] = ceil(constants[0]) - computed_constants[142] = floor(constants[0]) - computed_constants[143] = min(constants[0], constants[1]) - computed_constants[144] = min(constants[0], min(constants[1], constants[2])) - computed_constants[145] = max(constants[0], constants[1]) - computed_constants[146] = max(constants[0], max(constants[1], constants[2])) - computed_constants[147] = fmod(constants[0], constants[1]) - computed_constants[148] = sin(constants[0]) - computed_constants[149] = cos(constants[0]) - computed_constants[150] = tan(constants[0]) - computed_constants[151] = sec(constants[0]) - computed_constants[152] = csc(constants[0]) - computed_constants[153] = cot(constants[0]) - computed_constants[154] = sinh(constants[0]) - computed_constants[155] = cosh(constants[0]) - computed_constants[156] = tanh(constants[0]) - computed_constants[157] = sech(constants[0]) - computed_constants[158] = csch(constants[0]) - computed_constants[159] = coth(constants[0]) - computed_constants[160] = asin(constants[0]) - computed_constants[161] = acos(constants[0]) - computed_constants[162] = atan(constants[0]) - computed_constants[163] = asec(constants[0]) - computed_constants[164] = acsc(constants[0]) - computed_constants[165] = acot(constants[0]) - computed_constants[166] = asinh(constants[0]) - computed_constants[167] = acosh(constants[0]) - computed_constants[168] = atanh(constants[0]/2.0) - computed_constants[169] = asech(constants[0]) - computed_constants[170] = acsch(constants[0]) - computed_constants[171] = acoth(2.0*constants[0]) - computed_constants[172] = constants[0] if gt_func(constants[0], constants[1]) else nan - computed_constants[173] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] - computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan - computed_constants[175] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] - computed_constants[176] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) - computed_constants[181] = constants[0] - computed_constants[188] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) - computed_constants[189] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) - computed_constants[190] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) - computed_constants[191] = and_func(constants[0], constants[1])/((constants[1] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[1] if gt_func(constants[2], constants[3]) else nan))) - computed_constants[192] = and_func(or_func(constants[0], constants[1]), and_func(xor_func(constants[0], constants[1]), and_func(constants[1] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), or_func(constants[0], constants[1]))))) - computed_constants[193] = or_func(and_func(constants[0], constants[1]), or_func(xor_func(constants[0], constants[1]), or_func(constants[1] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) - computed_constants[194] = xor_func(and_func(constants[0], constants[1]), xor_func(or_func(constants[0], constants[1]), xor_func(constants[1] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), or_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) - computed_constants[195] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) - computed_constants[196] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) - computed_constants[197] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): + computed_constants[116] = pow(constants[0], 1.0/3.0) + computed_constants[117] = pow(constants[0], 1.0/constants[1]) + computed_constants[118] = pow(lt_func(constants[0], constants[1]), 1.0/gt_func(constants[3], constants[2])) + computed_constants[119] = pow(constants[0]+constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[120] = pow(constants[0], 1.0/gt_func(constants[2], constants[1])) + computed_constants[121] = pow(constants[0]-constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[122] = pow(-constants[0], 1.0/gt_func(constants[2], constants[1])) + computed_constants[123] = pow(constants[0]*constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[124] = pow(constants[0]/constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[125] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]+constants[3])) + computed_constants[126] = pow(lt_func(constants[0], constants[1]), 1.0/constants[2]) + computed_constants[127] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]-constants[3])) + computed_constants[128] = pow(lt_func(constants[0], constants[1]), 1.0/-constants[2]) + computed_constants[129] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]*constants[3])) + computed_constants[130] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]/constants[3])) + computed_constants[131] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])) + computed_constants[132] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])) + computed_constants[133] = fabs(constants[0]) + computed_constants[134] = exp(constants[0]) + computed_constants[135] = log(constants[0]) + computed_constants[136] = log10(constants[0]) + computed_constants[137] = log(constants[0])/log(2.0) + computed_constants[138] = log10(constants[0]) + computed_constants[139] = log(constants[0])/log(constants[1]) + computed_constants[140] = ceil(constants[0]) + computed_constants[141] = floor(constants[0]) + computed_constants[142] = min(constants[0], constants[1]) + computed_constants[143] = min(constants[0], min(constants[1], constants[2])) + computed_constants[144] = max(constants[0], constants[1]) + computed_constants[145] = max(constants[0], max(constants[1], constants[2])) + computed_constants[146] = fmod(constants[0], constants[1]) + computed_constants[147] = sin(constants[0]) + computed_constants[148] = cos(constants[0]) + computed_constants[149] = tan(constants[0]) + computed_constants[150] = sec(constants[0]) + computed_constants[151] = csc(constants[0]) + computed_constants[152] = cot(constants[0]) + computed_constants[153] = sinh(constants[0]) + computed_constants[154] = cosh(constants[0]) + computed_constants[155] = tanh(constants[0]) + computed_constants[156] = sech(constants[0]) + computed_constants[157] = csch(constants[0]) + computed_constants[158] = coth(constants[0]) + computed_constants[159] = asin(constants[0]) + computed_constants[160] = acos(constants[0]) + computed_constants[161] = atan(constants[0]) + computed_constants[162] = asec(constants[0]) + computed_constants[163] = acsc(constants[0]) + computed_constants[164] = acot(constants[0]) + computed_constants[165] = asinh(constants[0]) + computed_constants[166] = acosh(constants[0]) + computed_constants[167] = atanh(constants[0]/2.0) + computed_constants[168] = asech(constants[0]) + computed_constants[169] = acsch(constants[0]) + computed_constants[170] = acoth(2.0*constants[0]) + computed_constants[171] = constants[0] if gt_func(constants[0], constants[1]) else nan + computed_constants[172] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] + computed_constants[173] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan + computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] + computed_constants[175] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) + computed_constants[180] = constants[0] + computed_constants[187] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) + computed_constants[188] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) + computed_constants[189] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) + computed_constants[190] = and_func(constants[0], constants[1])/((constants[1] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[1] if gt_func(constants[2], constants[3]) else nan))) + computed_constants[191] = and_func(or_func(constants[0], constants[1]), and_func(xor_func(constants[0], constants[1]), and_func(constants[1] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), or_func(constants[0], constants[1]))))) + computed_constants[192] = or_func(and_func(constants[0], constants[1]), or_func(xor_func(constants[0], constants[1]), or_func(constants[1] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) + computed_constants[193] = xor_func(and_func(constants[0], constants[1]), xor_func(or_func(constants[0], constants[1]), xor_func(constants[1] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), or_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) + computed_constants[194] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) + computed_constants[195] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) + computed_constants[196] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) find_root_0(voi, states, rates, constants, computed_constants, algebraic) diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index acd776c9f..6391e30e4 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -85,6 +85,7 @@ typedef struct { double *constants; double *computedConstants; double *algebraic; + double *externals; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -103,7 +104,7 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[1] = u[1]; f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; - f[1] = algebraic[0]-algebraic[1]-(computedConstants[198]+computedConstants[199]); + f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) @@ -120,32 +121,6 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou algebraic[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) -{ - states[0] = 0.0; - constants[0] = 1.0; - constants[1] = 2.0; - constants[2] = 3.0; - constants[3] = 4.0; - constants[4] = 5.0; - constants[5] = 6.0; - constants[6] = 7.0; - computedConstants[177] = 123.0; - computedConstants[178] = 123.456789; - computedConstants[179] = 123.0e99; - computedConstants[180] = 123.456789e99; - computedConstants[182] = 1.0; - computedConstants[183] = 0.0; - computedConstants[184] = 2.71828182845905; - computedConstants[185] = 3.14159265358979; - computedConstants[186] = INFINITY; - computedConstants[187] = NAN; - computedConstants[198] = 1.0; - computedConstants[199] = 3.0; - algebraic[0] = 1.0; - algebraic[1] = 2.0; -} - void computeComputedConstants(double *constants, double *computedConstants) { computedConstants[0] = constants[0] == constants[1]; @@ -209,136 +184,135 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[58] = (constants[0] < constants[1])^(constants[2]^^(1.0/constants[3])); computedConstants[59] = constants[0]/(constants[1]^constants[2]); computedConstants[60] = !constants[0]; - computedConstants[61] = constants[0]+constants[1]; - computedConstants[62] = constants[0]+constants[1]+constants[2]; - computedConstants[63] = (constants[0] < constants[1])+(constants[2] > constants[3]); - computedConstants[64] = constants[0]; - computedConstants[65] = constants[0]-constants[1]; - computedConstants[66] = (constants[0] < constants[1])-(constants[2] > constants[3]); - computedConstants[67] = (constants[0] < constants[1])-(constants[2]+constants[3]); - computedConstants[68] = (constants[0] < constants[1])-constants[2]; - computedConstants[69] = constants[0]-(-constants[1]); - computedConstants[70] = constants[0]-(-constants[1]*constants[2]); - computedConstants[71] = -constants[0]; - computedConstants[72] = -(constants[0] < constants[1]); - computedConstants[73] = constants[0]*constants[1]; - computedConstants[74] = constants[0]*constants[1]*constants[2]; - computedConstants[75] = (constants[0] < constants[1])*(constants[2] > constants[3]); - computedConstants[76] = (constants[0]+constants[1])*(constants[2] > constants[3]); - computedConstants[77] = constants[0]*(constants[1] > constants[2]); - computedConstants[78] = (constants[0]-constants[1])*(constants[2] > constants[3]); - computedConstants[79] = -constants[0]*(constants[1] > constants[2]); - computedConstants[80] = (constants[0] < constants[1])*(constants[2]+constants[3]); - computedConstants[81] = (constants[0] < constants[1])*constants[2]; - computedConstants[82] = (constants[0] < constants[1])*(constants[2]-constants[3]); - computedConstants[83] = (constants[0] < constants[1])*-constants[2]; - computedConstants[84] = constants[0]/constants[1]; - computedConstants[85] = (constants[0] < constants[1])/(constants[3] > constants[2]); - computedConstants[86] = (constants[0]+constants[1])/(constants[3] > constants[2]); - computedConstants[87] = constants[0]/(constants[2] > constants[1]); - computedConstants[88] = (constants[0]-constants[1])/(constants[3] > constants[2]); - computedConstants[89] = -constants[0]/(constants[2] > constants[1]); - computedConstants[90] = (constants[0] < constants[1])/(constants[2]+constants[3]); - computedConstants[91] = (constants[0] < constants[1])/constants[2]; - computedConstants[92] = (constants[0] < constants[1])/(constants[2]-constants[3]); - computedConstants[93] = (constants[0] < constants[1])/-constants[2]; - computedConstants[94] = (constants[0] < constants[1])/(constants[2]*constants[3]); - computedConstants[95] = (constants[0] < constants[1])/(constants[2]/constants[3]); - computedConstants[96] = sqrt(constants[0]); - computedConstants[97] = sqr(constants[0]); - computedConstants[98] = constants[0]^^3.0; - computedConstants[99] = constants[0]^^constants[1]; - computedConstants[100] = (constants[0] <= constants[1])^^(constants[2] >= constants[3]); - computedConstants[101] = (constants[0]+constants[1])^^(constants[2] >= constants[3]); - computedConstants[102] = constants[0]^^(constants[1] >= constants[2]); - computedConstants[103] = (constants[0]-constants[1])^^(constants[2] >= constants[3]); - computedConstants[104] = (-constants[0])^^(constants[1] >= constants[2]); - computedConstants[105] = (constants[0]*constants[1])^^(constants[2] >= constants[3]); - computedConstants[106] = (constants[0]/constants[1])^^(constants[2] >= constants[3]); - computedConstants[107] = (constants[0] <= constants[1])^^(constants[2]+constants[3]); - computedConstants[108] = (constants[0] <= constants[1])^^constants[2]; - computedConstants[109] = (constants[0] <= constants[1])^^constants[2]-constants[3]; - computedConstants[110] = (constants[0] <= constants[1])^^-constants[2]; - computedConstants[111] = (constants[0] <= constants[1])^^(constants[2]*constants[3]); - computedConstants[112] = (constants[0] <= constants[1])^^(constants[2]/constants[3]); - computedConstants[113] = (constants[0] <= constants[1])^^(constants[2]^^constants[3]); - computedConstants[114] = (constants[0] <= constants[1])^^(constants[2]^^(1.0/constants[3])); + computedConstants[61] = constants[0]+constants[1]+constants[2]; + computedConstants[62] = (constants[0] < constants[1])+(constants[2] > constants[3]); + computedConstants[63] = constants[0]; + computedConstants[64] = constants[0]-constants[1]; + computedConstants[65] = (constants[0] < constants[1])-(constants[2] > constants[3]); + computedConstants[66] = (constants[0] < constants[1])-(constants[2]+constants[3]); + computedConstants[67] = (constants[0] < constants[1])-constants[2]; + computedConstants[68] = constants[0]-(-constants[1]); + computedConstants[69] = constants[0]-(-constants[1]*constants[2]); + computedConstants[70] = -constants[0]; + computedConstants[71] = -(constants[0] < constants[1]); + computedConstants[72] = constants[0]*constants[1]; + computedConstants[73] = constants[0]*constants[1]*constants[2]; + computedConstants[74] = (constants[0] < constants[1])*(constants[2] > constants[3]); + computedConstants[75] = (constants[0]+constants[1])*(constants[2] > constants[3]); + computedConstants[76] = constants[0]*(constants[1] > constants[2]); + computedConstants[77] = (constants[0]-constants[1])*(constants[2] > constants[3]); + computedConstants[78] = -constants[0]*(constants[1] > constants[2]); + computedConstants[79] = (constants[0] < constants[1])*(constants[2]+constants[3]); + computedConstants[80] = (constants[0] < constants[1])*constants[2]; + computedConstants[81] = (constants[0] < constants[1])*(constants[2]-constants[3]); + computedConstants[82] = (constants[0] < constants[1])*-constants[2]; + computedConstants[83] = constants[0]/constants[1]; + computedConstants[84] = (constants[0] < constants[1])/(constants[3] > constants[2]); + computedConstants[85] = (constants[0]+constants[1])/(constants[3] > constants[2]); + computedConstants[86] = constants[0]/(constants[2] > constants[1]); + computedConstants[87] = (constants[0]-constants[1])/(constants[3] > constants[2]); + computedConstants[88] = -constants[0]/(constants[2] > constants[1]); + computedConstants[89] = (constants[0] < constants[1])/(constants[2]+constants[3]); + computedConstants[90] = (constants[0] < constants[1])/constants[2]; + computedConstants[91] = (constants[0] < constants[1])/(constants[2]-constants[3]); + computedConstants[92] = (constants[0] < constants[1])/-constants[2]; + computedConstants[93] = (constants[0] < constants[1])/(constants[2]*constants[3]); + computedConstants[94] = (constants[0] < constants[1])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[0]); + computedConstants[96] = sqr(constants[0]); + computedConstants[97] = constants[0]^^3.0; + computedConstants[98] = constants[0]^^constants[1]; + computedConstants[99] = (constants[0] <= constants[1])^^(constants[2] >= constants[3]); + computedConstants[100] = (constants[0]+constants[1])^^(constants[2] >= constants[3]); + computedConstants[101] = constants[0]^^(constants[1] >= constants[2]); + computedConstants[102] = (constants[0]-constants[1])^^(constants[2] >= constants[3]); + computedConstants[103] = (-constants[0])^^(constants[1] >= constants[2]); + computedConstants[104] = (constants[0]*constants[1])^^(constants[2] >= constants[3]); + computedConstants[105] = (constants[0]/constants[1])^^(constants[2] >= constants[3]); + computedConstants[106] = (constants[0] <= constants[1])^^(constants[2]+constants[3]); + computedConstants[107] = (constants[0] <= constants[1])^^constants[2]; + computedConstants[108] = (constants[0] <= constants[1])^^constants[2]-constants[3]; + computedConstants[109] = (constants[0] <= constants[1])^^-constants[2]; + computedConstants[110] = (constants[0] <= constants[1])^^(constants[2]*constants[3]); + computedConstants[111] = (constants[0] <= constants[1])^^(constants[2]/constants[3]); + computedConstants[112] = (constants[0] <= constants[1])^^(constants[2]^^constants[3]); + computedConstants[113] = (constants[0] <= constants[1])^^(constants[2]^^(1.0/constants[3])); + computedConstants[114] = sqrt(constants[0]); computedConstants[115] = sqrt(constants[0]); - computedConstants[116] = sqrt(constants[0]); - computedConstants[117] = constants[0]^^(1.0/3.0); - computedConstants[118] = constants[0]^^(1.0/constants[1]); - computedConstants[119] = (constants[0] < constants[1])^^(1.0/(constants[3] > constants[2])); - computedConstants[120] = (constants[0]+constants[1])^^(1.0/(constants[3] > constants[2])); - computedConstants[121] = constants[0]^^(1.0/(constants[2] > constants[1])); - computedConstants[122] = (constants[0]-constants[1])^^(1.0/(constants[3] > constants[2])); - computedConstants[123] = (-constants[0])^^(1.0/(constants[2] > constants[1])); - computedConstants[124] = (constants[0]*constants[1])^^(1.0/(constants[3] > constants[2])); - computedConstants[125] = (constants[0]/constants[1])^^(1.0/(constants[3] > constants[2])); - computedConstants[126] = (constants[0] < constants[1])^^(1.0/(constants[2]+constants[3])); - computedConstants[127] = (constants[0] < constants[1])^^(1.0/constants[2]); - computedConstants[128] = (constants[0] < constants[1])^^(1.0/(constants[2]-constants[3])); - computedConstants[129] = (constants[0] < constants[1])^^(1.0/(-constants[2])); - computedConstants[130] = (constants[0] < constants[1])^^(1.0/(constants[2]*constants[3])); - computedConstants[131] = (constants[0] < constants[1])^^(1.0/(constants[2]/constants[3])); - computedConstants[132] = (constants[0] < constants[1])^^(1.0/(constants[2]^^constants[3])); - computedConstants[133] = (constants[0] < constants[1])^^(1.0/(constants[2]^^(1.0/constants[3]))); - computedConstants[134] = fabs(constants[0]); - computedConstants[135] = exp(constants[0]); - computedConstants[136] = log(constants[0]); - computedConstants[137] = log10(constants[0]); - computedConstants[138] = log(constants[0])/log(2.0); - computedConstants[139] = log10(constants[0]); - computedConstants[140] = log(constants[0])/log(constants[1]); - computedConstants[141] = ceil(constants[0]); - computedConstants[142] = floor(constants[0]); - computedConstants[143] = min(constants[0], constants[1]); - computedConstants[144] = min(constants[0], min(constants[1], constants[2])); - computedConstants[145] = max(constants[0], constants[1]); - computedConstants[146] = max(constants[0], max(constants[1], constants[2])); - computedConstants[147] = fmod(constants[0], constants[1]); - computedConstants[148] = sin(constants[0]); - computedConstants[149] = cos(constants[0]); - computedConstants[150] = tan(constants[0]); - computedConstants[151] = sec(constants[0]); - computedConstants[152] = csc(constants[0]); - computedConstants[153] = cot(constants[0]); - computedConstants[154] = sinh(constants[0]); - computedConstants[155] = cosh(constants[0]); - computedConstants[156] = tanh(constants[0]); - computedConstants[157] = sech(constants[0]); - computedConstants[158] = csch(constants[0]); - computedConstants[159] = coth(constants[0]); - computedConstants[160] = asin(constants[0]); - computedConstants[161] = acos(constants[0]); - computedConstants[162] = atan(constants[0]); - computedConstants[163] = asec(constants[0]); - computedConstants[164] = acsc(constants[0]); - computedConstants[165] = acot(constants[0]); - computedConstants[166] = asinh(constants[0]); - computedConstants[167] = acosh(constants[0]); - computedConstants[168] = atanh(constants[0]/2.0); - computedConstants[169] = asech(constants[0]); - computedConstants[170] = acsch(constants[0]); - computedConstants[171] = acoth(2.0*constants[0]); - computedConstants[172] = piecewise(constants[0] > constants[1], constants[0], NAN); - computedConstants[173] = piecewise(constants[0] > constants[1], constants[0], constants[2]); - computedConstants[174] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], NAN))); - computedConstants[175] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], constants[6]))); - computedConstants[176] = 123.0+piecewise(constants[0] > constants[1], constants[0], NAN); - computedConstants[181] = constants[0]; - computedConstants[188] = (constants[0] && constants[1])+piecewise(constants[2] > constants[3], constants[1], NAN)+constants[4]+(constants[5] && constants[6]); - computedConstants[189] = (constants[0] && constants[1])-(piecewise(constants[2] > constants[3], constants[1], NAN)-(constants[4]-piecewise(constants[2] > constants[3], constants[1], NAN)))-(constants[5] && constants[6]); - computedConstants[190] = (constants[0] && constants[1])*piecewise(constants[2] > constants[3], constants[1], NAN)*constants[4]*piecewise(constants[2] > constants[3], constants[1], NAN)*(constants[5] && constants[6]); - computedConstants[191] = (constants[0] && constants[1])/(piecewise(constants[2] > constants[3], constants[1], NAN)/(constants[4]/piecewise(constants[2] > constants[3], constants[1], NAN))); - computedConstants[192] = (constants[0] || constants[1]) && (constants[0]^constants[1]) && piecewise(constants[2] > constants[3], constants[1], NAN) && constants[4] && piecewise(constants[2] > constants[3], constants[1], NAN) && (constants[0]^constants[1]) && (constants[0] || constants[1]); - computedConstants[193] = (constants[0] && constants[1]) || (constants[0]^constants[1]) || piecewise(constants[2] > constants[3], constants[1], NAN) || constants[4] || piecewise(constants[2] > constants[3], constants[1], NAN) || (constants[0]^constants[1]) || (constants[0] && constants[1]); - computedConstants[194] = (constants[0] && constants[1])^(constants[0] || constants[1])^piecewise(constants[2] > constants[3], constants[1], NAN)^constants[4]^piecewise(constants[2] > constants[3], constants[1], NAN)^(constants[0] || constants[1])^(constants[0] && constants[1]); - computedConstants[195] = (constants[0] && constants[1])^^(piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[4]^^piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[0] && constants[1]))); - computedConstants[196] = (constants[0] && constants[1])^^(1.0/(piecewise(constants[2] > constants[3], constants[1], NAN)^^(1.0/constants[4])))^^(1.0/piecewise(constants[2] > constants[3], constants[1], NAN))^^(1.0/(constants[0] && constants[1])); - computedConstants[197] = -(constants[0] && constants[1])+-piecewise(constants[2] > constants[3], constants[1], NAN); + computedConstants[116] = constants[0]^^(1.0/3.0); + computedConstants[117] = constants[0]^^(1.0/constants[1]); + computedConstants[118] = (constants[0] < constants[1])^^(1.0/(constants[3] > constants[2])); + computedConstants[119] = (constants[0]+constants[1])^^(1.0/(constants[3] > constants[2])); + computedConstants[120] = constants[0]^^(1.0/(constants[2] > constants[1])); + computedConstants[121] = (constants[0]-constants[1])^^(1.0/(constants[3] > constants[2])); + computedConstants[122] = (-constants[0])^^(1.0/(constants[2] > constants[1])); + computedConstants[123] = (constants[0]*constants[1])^^(1.0/(constants[3] > constants[2])); + computedConstants[124] = (constants[0]/constants[1])^^(1.0/(constants[3] > constants[2])); + computedConstants[125] = (constants[0] < constants[1])^^(1.0/(constants[2]+constants[3])); + computedConstants[126] = (constants[0] < constants[1])^^(1.0/constants[2]); + computedConstants[127] = (constants[0] < constants[1])^^(1.0/(constants[2]-constants[3])); + computedConstants[128] = (constants[0] < constants[1])^^(1.0/(-constants[2])); + computedConstants[129] = (constants[0] < constants[1])^^(1.0/(constants[2]*constants[3])); + computedConstants[130] = (constants[0] < constants[1])^^(1.0/(constants[2]/constants[3])); + computedConstants[131] = (constants[0] < constants[1])^^(1.0/(constants[2]^^constants[3])); + computedConstants[132] = (constants[0] < constants[1])^^(1.0/(constants[2]^^(1.0/constants[3]))); + computedConstants[133] = fabs(constants[0]); + computedConstants[134] = exp(constants[0]); + computedConstants[135] = log(constants[0]); + computedConstants[136] = log10(constants[0]); + computedConstants[137] = log(constants[0])/log(2.0); + computedConstants[138] = log10(constants[0]); + computedConstants[139] = log(constants[0])/log(constants[1]); + computedConstants[140] = ceil(constants[0]); + computedConstants[141] = floor(constants[0]); + computedConstants[142] = min(constants[0], constants[1]); + computedConstants[143] = min(constants[0], min(constants[1], constants[2])); + computedConstants[144] = max(constants[0], constants[1]); + computedConstants[145] = max(constants[0], max(constants[1], constants[2])); + computedConstants[146] = fmod(constants[0], constants[1]); + computedConstants[147] = sin(constants[0]); + computedConstants[148] = cos(constants[0]); + computedConstants[149] = tan(constants[0]); + computedConstants[150] = sec(constants[0]); + computedConstants[151] = csc(constants[0]); + computedConstants[152] = cot(constants[0]); + computedConstants[153] = sinh(constants[0]); + computedConstants[154] = cosh(constants[0]); + computedConstants[155] = tanh(constants[0]); + computedConstants[156] = sech(constants[0]); + computedConstants[157] = csch(constants[0]); + computedConstants[158] = coth(constants[0]); + computedConstants[159] = asin(constants[0]); + computedConstants[160] = acos(constants[0]); + computedConstants[161] = atan(constants[0]); + computedConstants[162] = asec(constants[0]); + computedConstants[163] = acsc(constants[0]); + computedConstants[164] = acot(constants[0]); + computedConstants[165] = asinh(constants[0]); + computedConstants[166] = acosh(constants[0]); + computedConstants[167] = atanh(constants[0]/2.0); + computedConstants[168] = asech(constants[0]); + computedConstants[169] = acsch(constants[0]); + computedConstants[170] = acoth(2.0*constants[0]); + computedConstants[171] = piecewise(constants[0] > constants[1], constants[0], NAN); + computedConstants[172] = piecewise(constants[0] > constants[1], constants[0], constants[2]); + computedConstants[173] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], NAN))); + computedConstants[174] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], constants[6]))); + computedConstants[175] = 123.0+piecewise(constants[0] > constants[1], constants[0], NAN); + computedConstants[180] = constants[0]; + computedConstants[187] = (constants[0] && constants[1])+piecewise(constants[2] > constants[3], constants[1], NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[0] && constants[1])-(piecewise(constants[2] > constants[3], constants[1], NAN)-(constants[4]-piecewise(constants[2] > constants[3], constants[1], NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[0] && constants[1])*piecewise(constants[2] > constants[3], constants[1], NAN)*constants[4]*piecewise(constants[2] > constants[3], constants[1], NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[0] && constants[1])/(piecewise(constants[2] > constants[3], constants[1], NAN)/(constants[4]/piecewise(constants[2] > constants[3], constants[1], NAN))); + computedConstants[191] = (constants[0] || constants[1]) && (constants[0]^constants[1]) && piecewise(constants[2] > constants[3], constants[1], NAN) && constants[4] && piecewise(constants[2] > constants[3], constants[1], NAN) && (constants[0]^constants[1]) && (constants[0] || constants[1]); + computedConstants[192] = (constants[0] && constants[1]) || (constants[0]^constants[1]) || piecewise(constants[2] > constants[3], constants[1], NAN) || constants[4] || piecewise(constants[2] > constants[3], constants[1], NAN) || (constants[0]^constants[1]) || (constants[0] && constants[1]); + computedConstants[193] = (constants[0] && constants[1])^(constants[0] || constants[1])^piecewise(constants[2] > constants[3], constants[1], NAN)^constants[4]^piecewise(constants[2] > constants[3], constants[1], NAN)^(constants[0] || constants[1])^(constants[0] && constants[1]); + computedConstants[194] = (constants[0] && constants[1])^^(piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[4]^^piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[0] && constants[1]))); + computedConstants[195] = (constants[0] && constants[1])^^(1.0/(piecewise(constants[2] > constants[3], constants[1], NAN)^^(1.0/constants[4])))^^(1.0/piecewise(constants[2] > constants[3], constants[1], NAN))^^(1.0/(constants[0] && constants[1])); + computedConstants[196] = -(constants[0] && constants[1])+-piecewise(constants[2] > constants[3], constants[1], NAN); } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { rates[0] = 1.0; } diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 779814e80..1fff7c331 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -9,8 +9,9 @@ STATE_COUNT = 1 CONSTANT_COUNT = 7 -COMPUTED_CONSTANT_COUNT = 200 +COMPUTED_CONSTANT_COUNT = 199 ALGEBRAIC_COUNT = 2 +EXTERNAL_COUNT = 1 VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} @@ -90,7 +91,6 @@ {"name": "eqnXorParenthesesRightRoot", "units": "dimensionless", "component": "my_component"}, {"name": "eqnXorCoverageParentheses", "units": "dimensionless", "component": "my_component"}, {"name": "eqnNot", "units": "dimensionless", "component": "my_component"}, - {"name": "eqnPlus", "units": "dimensionless", "component": "my_component"}, {"name": "eqnPlusMultiple", "units": "dimensionless", "component": "my_component"}, {"name": "eqnPlusParentheses", "units": "dimensionless", "component": "my_component"}, {"name": "eqnPlusUnary", "units": "dimensionless", "component": "my_component"}, @@ -236,6 +236,10 @@ {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"} ] +EXTERNAL_INFO = [ + {"name": "eqnPlus", "units": "dimensionless", "component": "my_component"} +] + def eq_func(x, y): return 1.0 if x == y else 0.0 @@ -355,6 +359,10 @@ def create_algebraic_array(): return [nan]*ALGEBRAIC_COUNT +def create_externals_array(): + return [nan]*EXTERNAL_COUNT + + from nlasolver import nla_solve @@ -370,7 +378,7 @@ def objective_function_0(u, f, data): algebraic[1] = u[1] f[0] = algebraic[0]+algebraic[1]+states[0]-0.0 - f[1] = algebraic[0]-algebraic[1]-(computed_constants[198]+computed_constants[199]) + f[1] = algebraic[0]-algebraic[1]-(computed_constants[197]+computed_constants[198]) def find_root_0(voi, states, rates, constants, computed_constants, algebraic): @@ -394,18 +402,18 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic constants[4] = 5.0 constants[5] = 6.0 constants[6] = 7.0 - computed_constants[177] = 123.0 - computed_constants[178] = 123.456789 - computed_constants[179] = 123.0e99 - computed_constants[180] = 123.456789e99 - computed_constants[182] = 1.0 - computed_constants[183] = 0.0 - computed_constants[184] = 2.71828182845905 - computed_constants[185] = 3.14159265358979 - computed_constants[186] = inf - computed_constants[187] = nan - computed_constants[198] = 1.0 - computed_constants[199] = 3.0 + computed_constants[176] = 123.0 + computed_constants[177] = 123.456789 + computed_constants[178] = 123.0e99 + computed_constants[179] = 123.456789e99 + computed_constants[181] = 1.0 + computed_constants[182] = 0.0 + computed_constants[183] = 2.71828182845905 + computed_constants[184] = 3.14159265358979 + computed_constants[185] = inf + computed_constants[186] = nan + computed_constants[197] = 1.0 + computed_constants[198] = 3.0 algebraic[0] = 1.0 algebraic[1] = 2.0 @@ -472,138 +480,138 @@ def compute_computed_constants(constants, computed_constants): computed_constants[58] = xor_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) computed_constants[59] = constants[0]/xor_func(constants[1], constants[2]) computed_constants[60] = not_func(constants[0]) - computed_constants[61] = constants[0]+constants[1] - computed_constants[62] = constants[0]+constants[1]+constants[2] - computed_constants[63] = lt_func(constants[0], constants[1])+gt_func(constants[2], constants[3]) - computed_constants[64] = constants[0] - computed_constants[65] = constants[0]-constants[1] - computed_constants[66] = lt_func(constants[0], constants[1])-gt_func(constants[2], constants[3]) - computed_constants[67] = lt_func(constants[0], constants[1])-(constants[2]+constants[3]) - computed_constants[68] = lt_func(constants[0], constants[1])-constants[2] - computed_constants[69] = constants[0]-(-constants[1]) - computed_constants[70] = constants[0]-(-constants[1]*constants[2]) - computed_constants[71] = -constants[0] - computed_constants[72] = -lt_func(constants[0], constants[1]) - computed_constants[73] = constants[0]*constants[1] - computed_constants[74] = constants[0]*constants[1]*constants[2] - computed_constants[75] = lt_func(constants[0], constants[1])*gt_func(constants[2], constants[3]) - computed_constants[76] = (constants[0]+constants[1])*gt_func(constants[2], constants[3]) - computed_constants[77] = constants[0]*gt_func(constants[1], constants[2]) - computed_constants[78] = (constants[0]-constants[1])*gt_func(constants[2], constants[3]) - computed_constants[79] = -constants[0]*gt_func(constants[1], constants[2]) - computed_constants[80] = lt_func(constants[0], constants[1])*(constants[2]+constants[3]) - computed_constants[81] = lt_func(constants[0], constants[1])*constants[2] - computed_constants[82] = lt_func(constants[0], constants[1])*(constants[2]-constants[3]) - computed_constants[83] = lt_func(constants[0], constants[1])*-constants[2] - computed_constants[84] = constants[0]/constants[1] - computed_constants[85] = lt_func(constants[0], constants[1])/gt_func(constants[3], constants[2]) - computed_constants[86] = (constants[0]+constants[1])/gt_func(constants[3], constants[2]) - computed_constants[87] = constants[0]/gt_func(constants[2], constants[1]) - computed_constants[88] = (constants[0]-constants[1])/gt_func(constants[3], constants[2]) - computed_constants[89] = -constants[0]/gt_func(constants[2], constants[1]) - computed_constants[90] = lt_func(constants[0], constants[1])/(constants[2]+constants[3]) - computed_constants[91] = lt_func(constants[0], constants[1])/constants[2] - computed_constants[92] = lt_func(constants[0], constants[1])/(constants[2]-constants[3]) - computed_constants[93] = lt_func(constants[0], constants[1])/-constants[2] - computed_constants[94] = lt_func(constants[0], constants[1])/(constants[2]*constants[3]) - computed_constants[95] = lt_func(constants[0], constants[1])/(constants[2]/constants[3]) - computed_constants[96] = sqrt(constants[0]) - computed_constants[97] = pow(constants[0], 2.0) - computed_constants[98] = pow(constants[0], 3.0) - computed_constants[99] = pow(constants[0], constants[1]) - computed_constants[100] = pow(leq_func(constants[0], constants[1]), geq_func(constants[2], constants[3])) - computed_constants[101] = pow(constants[0]+constants[1], geq_func(constants[2], constants[3])) - computed_constants[102] = pow(constants[0], geq_func(constants[1], constants[2])) - computed_constants[103] = pow(constants[0]-constants[1], geq_func(constants[2], constants[3])) - computed_constants[104] = pow(-constants[0], geq_func(constants[1], constants[2])) - computed_constants[105] = pow(constants[0]*constants[1], geq_func(constants[2], constants[3])) - computed_constants[106] = pow(constants[0]/constants[1], geq_func(constants[2], constants[3])) - computed_constants[107] = pow(leq_func(constants[0], constants[1]), constants[2]+constants[3]) - computed_constants[108] = pow(leq_func(constants[0], constants[1]), constants[2]) - computed_constants[109] = pow(leq_func(constants[0], constants[1]), constants[2]-constants[3]) - computed_constants[110] = pow(leq_func(constants[0], constants[1]), -constants[2]) - computed_constants[111] = pow(leq_func(constants[0], constants[1]), constants[2]*constants[3]) - computed_constants[112] = pow(leq_func(constants[0], constants[1]), constants[2]/constants[3]) - computed_constants[113] = pow(leq_func(constants[0], constants[1]), pow(constants[2], constants[3])) - computed_constants[114] = pow(leq_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[61] = constants[0]+constants[1]+constants[2] + computed_constants[62] = lt_func(constants[0], constants[1])+gt_func(constants[2], constants[3]) + computed_constants[63] = constants[0] + computed_constants[64] = constants[0]-constants[1] + computed_constants[65] = lt_func(constants[0], constants[1])-gt_func(constants[2], constants[3]) + computed_constants[66] = lt_func(constants[0], constants[1])-(constants[2]+constants[3]) + computed_constants[67] = lt_func(constants[0], constants[1])-constants[2] + computed_constants[68] = constants[0]-(-constants[1]) + computed_constants[69] = constants[0]-(-constants[1]*constants[2]) + computed_constants[70] = -constants[0] + computed_constants[71] = -lt_func(constants[0], constants[1]) + computed_constants[72] = constants[0]*constants[1] + computed_constants[73] = constants[0]*constants[1]*constants[2] + computed_constants[74] = lt_func(constants[0], constants[1])*gt_func(constants[2], constants[3]) + computed_constants[75] = (constants[0]+constants[1])*gt_func(constants[2], constants[3]) + computed_constants[76] = constants[0]*gt_func(constants[1], constants[2]) + computed_constants[77] = (constants[0]-constants[1])*gt_func(constants[2], constants[3]) + computed_constants[78] = -constants[0]*gt_func(constants[1], constants[2]) + computed_constants[79] = lt_func(constants[0], constants[1])*(constants[2]+constants[3]) + computed_constants[80] = lt_func(constants[0], constants[1])*constants[2] + computed_constants[81] = lt_func(constants[0], constants[1])*(constants[2]-constants[3]) + computed_constants[82] = lt_func(constants[0], constants[1])*-constants[2] + computed_constants[83] = constants[0]/constants[1] + computed_constants[84] = lt_func(constants[0], constants[1])/gt_func(constants[3], constants[2]) + computed_constants[85] = (constants[0]+constants[1])/gt_func(constants[3], constants[2]) + computed_constants[86] = constants[0]/gt_func(constants[2], constants[1]) + computed_constants[87] = (constants[0]-constants[1])/gt_func(constants[3], constants[2]) + computed_constants[88] = -constants[0]/gt_func(constants[2], constants[1]) + computed_constants[89] = lt_func(constants[0], constants[1])/(constants[2]+constants[3]) + computed_constants[90] = lt_func(constants[0], constants[1])/constants[2] + computed_constants[91] = lt_func(constants[0], constants[1])/(constants[2]-constants[3]) + computed_constants[92] = lt_func(constants[0], constants[1])/-constants[2] + computed_constants[93] = lt_func(constants[0], constants[1])/(constants[2]*constants[3]) + computed_constants[94] = lt_func(constants[0], constants[1])/(constants[2]/constants[3]) + computed_constants[95] = sqrt(constants[0]) + computed_constants[96] = pow(constants[0], 2.0) + computed_constants[97] = pow(constants[0], 3.0) + computed_constants[98] = pow(constants[0], constants[1]) + computed_constants[99] = pow(leq_func(constants[0], constants[1]), geq_func(constants[2], constants[3])) + computed_constants[100] = pow(constants[0]+constants[1], geq_func(constants[2], constants[3])) + computed_constants[101] = pow(constants[0], geq_func(constants[1], constants[2])) + computed_constants[102] = pow(constants[0]-constants[1], geq_func(constants[2], constants[3])) + computed_constants[103] = pow(-constants[0], geq_func(constants[1], constants[2])) + computed_constants[104] = pow(constants[0]*constants[1], geq_func(constants[2], constants[3])) + computed_constants[105] = pow(constants[0]/constants[1], geq_func(constants[2], constants[3])) + computed_constants[106] = pow(leq_func(constants[0], constants[1]), constants[2]+constants[3]) + computed_constants[107] = pow(leq_func(constants[0], constants[1]), constants[2]) + computed_constants[108] = pow(leq_func(constants[0], constants[1]), constants[2]-constants[3]) + computed_constants[109] = pow(leq_func(constants[0], constants[1]), -constants[2]) + computed_constants[110] = pow(leq_func(constants[0], constants[1]), constants[2]*constants[3]) + computed_constants[111] = pow(leq_func(constants[0], constants[1]), constants[2]/constants[3]) + computed_constants[112] = pow(leq_func(constants[0], constants[1]), pow(constants[2], constants[3])) + computed_constants[113] = pow(leq_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) + computed_constants[114] = sqrt(constants[0]) computed_constants[115] = sqrt(constants[0]) - computed_constants[116] = sqrt(constants[0]) - computed_constants[117] = pow(constants[0], 1.0/3.0) - computed_constants[118] = pow(constants[0], 1.0/constants[1]) - computed_constants[119] = pow(lt_func(constants[0], constants[1]), 1.0/gt_func(constants[3], constants[2])) - computed_constants[120] = pow(constants[0]+constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[121] = pow(constants[0], 1.0/gt_func(constants[2], constants[1])) - computed_constants[122] = pow(constants[0]-constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[123] = pow(-constants[0], 1.0/gt_func(constants[2], constants[1])) - computed_constants[124] = pow(constants[0]*constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[125] = pow(constants[0]/constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[126] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]+constants[3])) - computed_constants[127] = pow(lt_func(constants[0], constants[1]), 1.0/constants[2]) - computed_constants[128] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]-constants[3])) - computed_constants[129] = pow(lt_func(constants[0], constants[1]), 1.0/-constants[2]) - computed_constants[130] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]*constants[3])) - computed_constants[131] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]/constants[3])) - computed_constants[132] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])) - computed_constants[133] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])) - computed_constants[134] = fabs(constants[0]) - computed_constants[135] = exp(constants[0]) - computed_constants[136] = log(constants[0]) - computed_constants[137] = log10(constants[0]) - computed_constants[138] = log(constants[0])/log(2.0) - computed_constants[139] = log10(constants[0]) - computed_constants[140] = log(constants[0])/log(constants[1]) - computed_constants[141] = ceil(constants[0]) - computed_constants[142] = floor(constants[0]) - computed_constants[143] = min(constants[0], constants[1]) - computed_constants[144] = min(constants[0], min(constants[1], constants[2])) - computed_constants[145] = max(constants[0], constants[1]) - computed_constants[146] = max(constants[0], max(constants[1], constants[2])) - computed_constants[147] = fmod(constants[0], constants[1]) - computed_constants[148] = sin(constants[0]) - computed_constants[149] = cos(constants[0]) - computed_constants[150] = tan(constants[0]) - computed_constants[151] = sec(constants[0]) - computed_constants[152] = csc(constants[0]) - computed_constants[153] = cot(constants[0]) - computed_constants[154] = sinh(constants[0]) - computed_constants[155] = cosh(constants[0]) - computed_constants[156] = tanh(constants[0]) - computed_constants[157] = sech(constants[0]) - computed_constants[158] = csch(constants[0]) - computed_constants[159] = coth(constants[0]) - computed_constants[160] = asin(constants[0]) - computed_constants[161] = acos(constants[0]) - computed_constants[162] = atan(constants[0]) - computed_constants[163] = asec(constants[0]) - computed_constants[164] = acsc(constants[0]) - computed_constants[165] = acot(constants[0]) - computed_constants[166] = asinh(constants[0]) - computed_constants[167] = acosh(constants[0]) - computed_constants[168] = atanh(constants[0]/2.0) - computed_constants[169] = asech(constants[0]) - computed_constants[170] = acsch(constants[0]) - computed_constants[171] = acoth(2.0*constants[0]) - computed_constants[172] = constants[0] if gt_func(constants[0], constants[1]) else nan - computed_constants[173] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] - computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan - computed_constants[175] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] - computed_constants[176] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) - computed_constants[181] = constants[0] - computed_constants[188] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) - computed_constants[189] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) - computed_constants[190] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) - computed_constants[191] = and_func(constants[0], constants[1])/((constants[1] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[1] if gt_func(constants[2], constants[3]) else nan))) - computed_constants[192] = and_func(or_func(constants[0], constants[1]), and_func(xor_func(constants[0], constants[1]), and_func(constants[1] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), or_func(constants[0], constants[1]))))) - computed_constants[193] = or_func(and_func(constants[0], constants[1]), or_func(xor_func(constants[0], constants[1]), or_func(constants[1] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) - computed_constants[194] = xor_func(and_func(constants[0], constants[1]), xor_func(or_func(constants[0], constants[1]), xor_func(constants[1] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), or_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) - computed_constants[195] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) - computed_constants[196] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) - computed_constants[197] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) - - -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): + computed_constants[116] = pow(constants[0], 1.0/3.0) + computed_constants[117] = pow(constants[0], 1.0/constants[1]) + computed_constants[118] = pow(lt_func(constants[0], constants[1]), 1.0/gt_func(constants[3], constants[2])) + computed_constants[119] = pow(constants[0]+constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[120] = pow(constants[0], 1.0/gt_func(constants[2], constants[1])) + computed_constants[121] = pow(constants[0]-constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[122] = pow(-constants[0], 1.0/gt_func(constants[2], constants[1])) + computed_constants[123] = pow(constants[0]*constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[124] = pow(constants[0]/constants[1], 1.0/gt_func(constants[3], constants[2])) + computed_constants[125] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]+constants[3])) + computed_constants[126] = pow(lt_func(constants[0], constants[1]), 1.0/constants[2]) + computed_constants[127] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]-constants[3])) + computed_constants[128] = pow(lt_func(constants[0], constants[1]), 1.0/-constants[2]) + computed_constants[129] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]*constants[3])) + computed_constants[130] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]/constants[3])) + computed_constants[131] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])) + computed_constants[132] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])) + computed_constants[133] = fabs(constants[0]) + computed_constants[134] = exp(constants[0]) + computed_constants[135] = log(constants[0]) + computed_constants[136] = log10(constants[0]) + computed_constants[137] = log(constants[0])/log(2.0) + computed_constants[138] = log10(constants[0]) + computed_constants[139] = log(constants[0])/log(constants[1]) + computed_constants[140] = ceil(constants[0]) + computed_constants[141] = floor(constants[0]) + computed_constants[142] = min(constants[0], constants[1]) + computed_constants[143] = min(constants[0], min(constants[1], constants[2])) + computed_constants[144] = max(constants[0], constants[1]) + computed_constants[145] = max(constants[0], max(constants[1], constants[2])) + computed_constants[146] = fmod(constants[0], constants[1]) + computed_constants[147] = sin(constants[0]) + computed_constants[148] = cos(constants[0]) + computed_constants[149] = tan(constants[0]) + computed_constants[150] = sec(constants[0]) + computed_constants[151] = csc(constants[0]) + computed_constants[152] = cot(constants[0]) + computed_constants[153] = sinh(constants[0]) + computed_constants[154] = cosh(constants[0]) + computed_constants[155] = tanh(constants[0]) + computed_constants[156] = sech(constants[0]) + computed_constants[157] = csch(constants[0]) + computed_constants[158] = coth(constants[0]) + computed_constants[159] = asin(constants[0]) + computed_constants[160] = acos(constants[0]) + computed_constants[161] = atan(constants[0]) + computed_constants[162] = asec(constants[0]) + computed_constants[163] = acsc(constants[0]) + computed_constants[164] = acot(constants[0]) + computed_constants[165] = asinh(constants[0]) + computed_constants[166] = acosh(constants[0]) + computed_constants[167] = atanh(constants[0]/2.0) + computed_constants[168] = asech(constants[0]) + computed_constants[169] = acsch(constants[0]) + computed_constants[170] = acoth(2.0*constants[0]) + computed_constants[171] = constants[0] if gt_func(constants[0], constants[1]) else nan + computed_constants[172] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] + computed_constants[173] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan + computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] + computed_constants[175] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) + computed_constants[180] = constants[0] + computed_constants[187] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) + computed_constants[188] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) + computed_constants[189] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) + computed_constants[190] = and_func(constants[0], constants[1])/((constants[1] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[1] if gt_func(constants[2], constants[3]) else nan))) + computed_constants[191] = and_func(or_func(constants[0], constants[1]), and_func(xor_func(constants[0], constants[1]), and_func(constants[1] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), or_func(constants[0], constants[1]))))) + computed_constants[192] = or_func(and_func(constants[0], constants[1]), or_func(xor_func(constants[0], constants[1]), or_func(constants[1] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) + computed_constants[193] = xor_func(and_func(constants[0], constants[1]), xor_func(or_func(constants[0], constants[1]), xor_func(constants[1] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), or_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) + computed_constants[194] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) + computed_constants[195] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) + computed_constants[196] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) find_root_0(voi, states, rates, constants, computed_constants, algebraic) From 68ad0fc67712b50b003cd9c3ced68d38982bc547 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 28 Aug 2024 17:22:19 +0200 Subject: [PATCH 48/74] Some minor cleaning up. --- src/analyser.cpp | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index e1a3ca780..6597ba0af 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -906,21 +906,20 @@ void Analyser::AnalyserImpl::analyseComponentVariables(const ComponentPtr &compo if ((variable != internalVariable->mVariable) && !variable->initialValue().empty()) { auto issue = Issue::IssueImpl::create(); - auto trackedVariableComponent = owningComponent(internalVariable->mVariable); issue->mPimpl->setDescription("Variable '" + variable->name() + "' in component '" + component->name() + "' and variable '" + internalVariable->mVariable->name() - + "' in component '" + trackedVariableComponent->name() + + "' in component '" + owningComponent(internalVariable->mVariable)->name() + "' are equivalent and cannot therefore both be initialised."); issue->mPimpl->setReferenceRule(Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE); issue->mPimpl->mItem->mPimpl->setVariable(variable); addIssue(issue); - } else if (!internalVariable->mVariable->initialValue().empty() - && !isCellMLReal(internalVariable->mVariable->initialValue())) { - auto initialisingComponent = owningComponent(internalVariable->mVariable); - auto initialisingVariable = initialisingComponent->variable(internalVariable->mVariable->initialValue()); + } else if (!variable->initialValue().empty() + && !isCellMLReal(variable->initialValue())) { + auto initialisingComponent = owningComponent(variable); + auto initialisingVariable = initialisingComponent->variable(variable->initialValue()); auto initialisingInternalVariable = Analyser::AnalyserImpl::internalVariable(initialisingVariable); if (initialisingInternalVariable->mType != AnalyserInternalVariable::Type::INITIALISED) { @@ -928,7 +927,7 @@ void Analyser::AnalyserImpl::analyseComponentVariables(const ComponentPtr &compo issue->mPimpl->setDescription("Variable '" + variable->name() + "' in component '" + component->name() - + "' is initialised using variable '" + internalVariable->mVariable->initialValue() + + "' is initialised using variable '" + variable->initialValue() + "', which is not a constant."); issue->mPimpl->setReferenceRule(Issue::ReferenceRule::ANALYSER_VARIABLE_NON_CONSTANT_INITIALISATION); issue->mPimpl->mItem->mPimpl->setVariable(variable); From ff5a1a2ea50f98de06e62792ee408582591adae4 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 27 Aug 2024 18:24:46 +0200 Subject: [PATCH 49/74] Analyser: improved unit scaling. --- src/analyser.cpp | 19 +- src/generator.cpp | 76 +++++--- src/generator_p.h | 2 + tests/generator/generator.cpp | 7 +- .../cellml_unit_scaling_constant/model.c | 48 +++++- .../cellml_unit_scaling_constant/model.cellml | 163 ++++++++++++++++-- .../cellml_unit_scaling_constant/model.h | 4 +- .../cellml_unit_scaling_constant/model.py | 48 +++++- 8 files changed, 307 insertions(+), 60 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index 6597ba0af..07e3d7103 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -918,8 +918,7 @@ void Analyser::AnalyserImpl::analyseComponentVariables(const ComponentPtr &compo addIssue(issue); } else if (!variable->initialValue().empty() && !isCellMLReal(variable->initialValue())) { - auto initialisingComponent = owningComponent(variable); - auto initialisingVariable = initialisingComponent->variable(variable->initialValue()); + auto initialisingVariable = owningComponent(variable)->variable(variable->initialValue()); auto initialisingInternalVariable = Analyser::AnalyserImpl::internalVariable(initialisingVariable); if (initialisingInternalVariable->mType != AnalyserInternalVariable::Type::INITIALISED) { @@ -933,6 +932,22 @@ void Analyser::AnalyserImpl::analyseComponentVariables(const ComponentPtr &compo issue->mPimpl->mItem->mPimpl->setVariable(variable); addIssue(issue); + } else { + auto scalingFactor = Units::scalingFactor(variable->units(), initialisingVariable->units()); + + if (!areNearlyEqual(scalingFactor, 1.0)) { + auto issue = Issue::IssueImpl::create(); + + issue->mPimpl->setDescription("Variable '" + variable->name() + + "' in component '" + component->name() + + "' is initialised using variable '" + variable->initialValue() + + "' which has different units."); + issue->mPimpl->setLevel(Issue::Level::WARNING); + issue->mPimpl->setReferenceRule(Issue::ReferenceRule::ANALYSER_VARIABLE_NON_CONSTANT_INITIALISATION); + issue->mPimpl->mItem->mPimpl->setVariable(variable); + + addIssue(issue); + } } } } diff --git a/src/generator.cpp b/src/generator.cpp index ac689f905..9483d5869 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -106,9 +106,22 @@ AnalyserVariablePtr Generator::GeneratorImpl::analyserVariable(const VariablePtr double Generator::GeneratorImpl::scalingFactor(const VariablePtr &variable) const { - // Return the scaling factor for the given variable. + // Return the scaling factor for the given variable, accounting for the fact that a constant may be initialised by + // another variable which initial value may be defined in a different component. - return Units::scalingFactor(variable->units(), analyserVariable(variable)->variable()->units()); + auto analyserVariable = Generator::GeneratorImpl::analyserVariable(variable); + + if ((analyserVariable->type() == AnalyserVariable::Type::CONSTANT) + && !isCellMLReal(variable->initialValue())) { + auto initialValueVariable = owningComponent(variable)->variable(variable->initialValue()); + auto initialValueAnalyserVariable = Generator::GeneratorImpl::analyserVariable(initialValueVariable); + + if (owningComponent(variable) != owningComponent(initialValueAnalyserVariable->variable())) { + return Units::scalingFactor(initialValueVariable->units(), variable->units()); + } + } + + return Units::scalingFactor(analyserVariable->variable()->units(), variable->units()); } bool Generator::GeneratorImpl::isNegativeNumber(const AnalyserEquationAstPtr &ast) const @@ -882,8 +895,8 @@ std::string Generator::GeneratorImpl::generateDoubleOrConstantVariableNameCode(c return generateDoubleCode(variable->initialValue()); } - auto initValueVariable = owningComponent(variable)->variable(variable->initialValue()); - auto analyserInitialValueVariable = analyserVariable(initValueVariable); + auto initialValueVariable = owningComponent(variable)->variable(variable->initialValue()); + auto analyserInitialValueVariable = analyserVariable(initialValueVariable); return mProfile->constantsArrayString() + mProfile->openArrayString() + convertToString(analyserInitialValueVariable->index()) + mProfile->closeArrayString(); } @@ -1687,7 +1700,7 @@ std::string Generator::GeneratorImpl::generateInitialisationCode(const AnalyserV std::string scalingFactorCode; if (!areNearlyEqual(scalingFactor, 1.0)) { - scalingFactorCode = generateDoubleCode(convertToString(1.0 / scalingFactor)) + mProfile->timesString(); + scalingFactorCode = generateDoubleCode(convertToString(scalingFactor)) + mProfile->timesString(); } return mProfile->indentString() @@ -1803,6 +1816,31 @@ void Generator::GeneratorImpl::addInterfaceComputeModelMethodsCode() } } +std::string Generator::GeneratorImpl::generateConstantInitialisationCode(const std::vector::iterator constant, + std::vector &remainingConstants) +{ + auto initialisingVariable = (*constant)->initialisingVariable(); + auto initialValue = initialisingVariable->initialValue(); + + if (!isCellMLReal(initialValue)) { + auto initialisingComponent = owningComponent(initialisingVariable); + auto crtConstant = std::find_if(remainingConstants.begin(), remainingConstants.end(), + [=](const AnalyserVariablePtr &av) -> bool { + return initialisingComponent->variable(initialValue) == av->variable(); + }); + + if (crtConstant != remainingConstants.end()) { + return generateConstantInitialisationCode(crtConstant, remainingConstants); + } + } + + auto code = generateInitialisationCode(*constant); + + remainingConstants.erase(constant); + + return code; +} + void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(std::vector &remainingEquations) { auto implementationInitialiseVariablesMethodString = mProfile->implementationInitialiseVariablesMethodString(modelHasOdes()); @@ -1816,25 +1854,17 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st for (const auto &state : mModel->states()) { auto initialisingVariable = state->initialisingVariable(); auto initialValue = initialisingVariable->initialValue(); - auto constant = constants.end(); - while (!isCellMLReal(initialValue)) { - // The initial value references another variable, so look for it keeping in mind that its initial value may - // reference another variable, and so on. + if (!isCellMLReal(initialValue)) { + // The initial value references a constant. auto initialisingComponent = owningComponent(initialisingVariable); - auto crtConstant = std::find_if(constants.begin(), constants.end(), - [=](const AnalyserVariablePtr &av) -> bool { return initialisingComponent->variable(initialValue)->hasEquivalentVariable(av->variable()); }); - - constant = crtConstant; - initialisingVariable = (*constant)->variable(); - initialValue = initialisingVariable->initialValue(); - } - - if (constant != constants.end()) { - methodBody += generateInitialisationCode(*constant); + auto constant = std::find_if(constants.begin(), constants.end(), + [=](const AnalyserVariablePtr &av) -> bool { + return initialisingComponent->variable(initialValue)->hasEquivalentVariable(av->variable()); + }); - constants.erase(constant); + methodBody += generateConstantInitialisationCode(constant, constants); } methodBody += generateInitialisationCode(state); @@ -1849,10 +1879,10 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st } } - // Initialise our constants. + // Initialise our (remaining) constants. - for (const auto &constant : constants) { - methodBody += generateInitialisationCode(constant); + while (!constants.empty()) { + methodBody += generateConstantInitialisationCode(constants.begin(), constants); } // Initialise our computed constants that are initialised using an equation (e.g., x = 3 rather than x with an diff --git a/src/generator_p.h b/src/generator_p.h index 8e4308c9c..d85e8e2f4 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -138,6 +138,8 @@ struct Generator::GeneratorImpl std::vector &remainingEquations); void addInterfaceComputeModelMethodsCode(); + std::string generateConstantInitialisationCode(const std::vector::iterator constant, + std::vector &remainingConstants); void addImplementationInitialiseVariablesMethodCode(std::vector &remainingEquations); void addImplementationComputeComputedConstantsMethodCode(std::vector &remainingEquations); void addImplementationComputeRatesMethodCode(std::vector &remainingEquations); diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index 1808a8d52..e6e327a4a 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -889,9 +889,14 @@ TEST(Generator, cellmlUnitScalingConstant) auto analyser = libcellml::Analyser::create(); + const std::vector expectedIssues = { + "Variable 'c_M' in component 'constants' is initialised using variable 'c' which has different units.", + "Variable 'oc_mM' in component 'other_constants' is initialised using variable 'c' which has different units.", + }; + analyser->analyseModel(model); - EXPECT_EQ(size_t(0), analyser->errorCount()); + EXPECT_EQ_ISSUES(expectedIssues, analyser); auto analyserModel = analyser->model(); auto generator = libcellml::Generator::create(); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 3d259be88..4b9bc87bc 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -8,17 +8,33 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; -const size_t CONSTANT_COUNT = 1; -const size_t COMPUTED_CONSTANT_COUNT = 2; +const size_t CONSTANT_COUNT = 9; +const size_t COMPUTED_CONSTANT_COUNT = 10; const size_t ALGEBRAIC_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { - {"k", "mM", "constants"} + {"ind_c_mM", "mM", "constants"}, + {"c_mM", "mM", "constants"}, + {"c", "mM", "constants"}, + {"c_M", "M", "constants"}, + {"ind_c_M", "M", "constants"}, + {"ind_oc_mM", "mM", "other_constants"}, + {"oc_mM", "mM", "other_constants"}, + {"oc_M", "M", "other_constants"}, + {"ind_oc_M", "M", "other_constants"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"x", "mM", "main"}, - {"y", "M", "main"} + {"comp_c_mM_mM", "mM", "main"}, + {"comp_c_mM_M", "M", "main"}, + {"comp_c_M_mM", "mM", "main"}, + {"comp_c_M_M", "M", "main"}, + {"comp_k_mM", "mM", "main"}, + {"comp_k_M", "M", "main"}, + {"comp_oc_mM_mM", "mM", "main"}, + {"comp_oc_mM_M", "M", "main"}, + {"comp_oc_M_mM", "mM", "main"}, + {"comp_oc_M_M", "M", "main"} }; const VariableInfo ALGEBRAIC_INFO[] = { @@ -64,13 +80,29 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { - constants[0] = 123.0; + constants[2] = 123.0; + constants[1] = constants[2]; + constants[0] = constants[1]; + constants[3] = constants[2]; + constants[4] = constants[3]; + constants[6] = 0.001*constants[2]; + constants[5] = constants[6]; + constants[7] = constants[2]; + constants[8] = constants[7]; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = constants[0]+constants[0]; - computedConstants[1] = 0.001*constants[0]+0.001*constants[0]; + computedConstants[0] = constants[1]+constants[0]; + computedConstants[1] = 0.001*constants[1]+0.001*constants[0]; + computedConstants[2] = 1000.0*constants[3]+1000.0*constants[4]; + computedConstants[3] = constants[3]+constants[4]; + computedConstants[4] = constants[2]+constants[2]; + computedConstants[5] = 0.001*constants[2]+0.001*constants[2]; + computedConstants[6] = constants[6]+constants[5]; + computedConstants[7] = 0.001*constants[6]+0.001*constants[5]; + computedConstants[8] = 1000.0*constants[7]+1000.0*constants[8]; + computedConstants[9] = constants[7]+constants[8]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.cellml b/tests/resources/generator/cellml_unit_scaling_constant/model.cellml index bc52f483e..08556a82c 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.cellml +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.cellml @@ -1,8 +1,11 @@ - + @@ -14,36 +17,164 @@ - + + + + + + + + + + + + - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - x + comp_c_mM_mM + + + c_mM_mM + ind_c_mM_mM + + + + + comp_c_mM_M + + + c_mM_M + ind_c_mM_M + + + + + comp_c_M_mM - k_x - k_x + c_M_mM + ind_c_M_mM - y + comp_c_M_M - k_y - k_y + c_M_M + ind_c_M_M + + + + + comp_k_mM + + + k_mM + k_mM + + + + + comp_k_M + + + k_M + k_M + + + + + comp_oc_mM_mM + + + oc_mM_mM + ind_oc_mM_mM + + + + + comp_oc_mM_M + + + oc_mM_M + ind_oc_mM_M + + + + + comp_oc_M_mM + + + oc_M_mM + ind_oc_M_mM + + + + + comp_oc_M_M + + + oc_M_M + ind_oc_M_M - - + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index 1e51b94dd..4ee62c7c6 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -12,9 +12,9 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_COUNT; typedef struct { - char name[2]; + char name[14]; char units[3]; - char component[10]; + char component[16]; } VariableInfo; extern const VariableInfo CONSTANT_INFO[]; diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index 16717c06e..b065335d3 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -7,17 +7,33 @@ __version__ = "0.5.0" LIBCELLML_VERSION = "0.5.0" -CONSTANT_COUNT = 1 -COMPUTED_CONSTANT_COUNT = 2 +CONSTANT_COUNT = 9 +COMPUTED_CONSTANT_COUNT = 10 ALGEBRAIC_COUNT = 0 CONSTANT_INFO = [ - {"name": "k", "units": "mM", "component": "constants"} + {"name": "ind_c_mM", "units": "mM", "component": "constants"}, + {"name": "c_mM", "units": "mM", "component": "constants"}, + {"name": "c", "units": "mM", "component": "constants"}, + {"name": "c_M", "units": "M", "component": "constants"}, + {"name": "ind_c_M", "units": "M", "component": "constants"}, + {"name": "ind_oc_mM", "units": "mM", "component": "other_constants"}, + {"name": "oc_mM", "units": "mM", "component": "other_constants"}, + {"name": "oc_M", "units": "M", "component": "other_constants"}, + {"name": "ind_oc_M", "units": "M", "component": "other_constants"} ] COMPUTED_CONSTANT_INFO = [ - {"name": "x", "units": "mM", "component": "main"}, - {"name": "y", "units": "M", "component": "main"} + {"name": "comp_c_mM_mM", "units": "mM", "component": "main"}, + {"name": "comp_c_mM_M", "units": "M", "component": "main"}, + {"name": "comp_c_M_mM", "units": "mM", "component": "main"}, + {"name": "comp_c_M_M", "units": "M", "component": "main"}, + {"name": "comp_k_mM", "units": "mM", "component": "main"}, + {"name": "comp_k_M", "units": "M", "component": "main"}, + {"name": "comp_oc_mM_mM", "units": "mM", "component": "main"}, + {"name": "comp_oc_mM_M", "units": "M", "component": "main"}, + {"name": "comp_oc_M_mM", "units": "mM", "component": "main"}, + {"name": "comp_oc_M_M", "units": "M", "component": "main"} ] ALGEBRAIC_INFO = [ @@ -37,12 +53,28 @@ def create_algebraic_array(): def initialise_variables(constants, computed_constants, algebraic): - constants[0] = 123.0 + constants[2] = 123.0 + constants[1] = constants[2] + constants[0] = constants[1] + constants[3] = constants[2] + constants[4] = constants[3] + constants[6] = 0.001*constants[2] + constants[5] = constants[6] + constants[7] = constants[2] + constants[8] = constants[7] def compute_computed_constants(constants, computed_constants): - computed_constants[0] = constants[0]+constants[0] - computed_constants[1] = 0.001*constants[0]+0.001*constants[0] + computed_constants[0] = constants[1]+constants[0] + computed_constants[1] = 0.001*constants[1]+0.001*constants[0] + computed_constants[2] = 1000.0*constants[3]+1000.0*constants[4] + computed_constants[3] = constants[3]+constants[4] + computed_constants[4] = constants[2]+constants[2] + computed_constants[5] = 0.001*constants[2]+0.001*constants[2] + computed_constants[6] = constants[6]+constants[5] + computed_constants[7] = 0.001*constants[6]+0.001*constants[5] + computed_constants[8] = 1000.0*constants[7]+1000.0*constants[8] + computed_constants[9] = constants[7]+constants[8] def compute_variables(constants, computed_constants, algebraic): From c83f5c7b7aacd85c4cef5c8e6c15ed0fdbe003bd Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Mon, 2 Sep 2024 23:21:04 +1200 Subject: [PATCH 50/74] Some minor cleaning up. --- src/debug.cpp | 8 +++----- src/generator.cpp | 8 +------- tests/bindings/javascript/analysermodel.test.js | 5 +++++ tests/bindings/javascript/analyservariable.test.js | 1 + 4 files changed, 10 insertions(+), 12 deletions(-) diff --git a/src/debug.cpp b/src/debug.cpp index f16c75456..8a7b330e6 100644 --- a/src/debug.cpp +++ b/src/debug.cpp @@ -29,8 +29,6 @@ limitations under the License. #include "commonutils.h" #include "utilities.h" -#include "libcellml/undefines.h" - namespace libcellml { std::string astAsCode(const AnalyserEquationAstPtr &ast) @@ -116,7 +114,7 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) Debug() << "\nNo algebraic variables"; } - if (eqn->algebraicCount() != 0) { + if (eqn->externalCount() != 0) { Debug() << "\nExternal variables:"; for (const auto &var : eqn->externals()) { @@ -150,7 +148,7 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) if (nlaSibling->ast() != nullptr) { Debug() << " - " << astAsCode(nlaSibling->ast()); } else if (nlaSibling->type() == AnalyserEquation::Type::EXTERNAL) { - Debug() << " - External equation for '" << nlaSibling->algebraic(0)->variable()->name() << "'"; + Debug() << " - External equation for '" << nlaSibling->external(0)->variable()->name() << "'"; } else { Debug() << " - ??? [" << AnalyserEquation::typeAsString(nlaSibling->type()) << "]"; } @@ -180,7 +178,7 @@ void printAnalyserModelVariables(const AnalyserModelPtr &model) if (eqn->ast() != nullptr) { Debug() << " - " << astAsCode(eqn->ast()); } else if (eqn->type() == AnalyserEquation::Type::EXTERNAL) { - Debug() << " - External equation for '" << eqn->algebraic(0)->variable()->name() << "'"; + Debug() << " - External equation for '" << eqn->external(0)->variable()->name() << "'"; } else { Debug() << " - ??? [" << AnalyserEquation::typeAsString(eqn->type()) << "]"; } diff --git a/src/generator.cpp b/src/generator.cpp index 9483d5869..38d25b7ee 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -484,11 +484,7 @@ void Generator::GeneratorImpl::doAddImplementationVariableInfoCode(const std::st void Generator::GeneratorImpl::addImplementationVariableInfoCode() { if (modelHasOdes()) { - std::vector variables; - - variables.push_back(mModel->voi()); - - doAddImplementationVariableInfoCode(mProfile->implementationVoiInfoString(), variables, true); + doAddImplementationVariableInfoCode(mProfile->implementationVoiInfoString(), {mModel->voi()}, true); } if (modelHasOdes()) { @@ -496,9 +492,7 @@ void Generator::GeneratorImpl::addImplementationVariableInfoCode() } doAddImplementationVariableInfoCode(mProfile->implementationConstantInfoString(), mModel->constants(), false); - doAddImplementationVariableInfoCode(mProfile->implementationComputedConstantInfoString(), mModel->computedConstants(), false); - doAddImplementationVariableInfoCode(mProfile->implementationAlgebraicInfoString(), mModel->algebraic(), false); if (mModel->hasExternalVariables()) { diff --git a/tests/bindings/javascript/analysermodel.test.js b/tests/bindings/javascript/analysermodel.test.js index 7c5ea9ada..3fe868c7a 100644 --- a/tests/bindings/javascript/analysermodel.test.js +++ b/tests/bindings/javascript/analysermodel.test.js @@ -76,6 +76,11 @@ describe("Analyser Model tests", () => { expect(am.algebraicVariables().size()).toBe(10) expect(am.algebraicVariable(2).variable().name()).toBe("i_K") }); + test('Checking Analyser Model external variables related API.', () => { + expect(am.externalCount()).toBe(0) + expect(am.externals().size()).toBe(0) + expect(am.external(0)).toBeNull() + }); test('Checking Analyser Model need* API.', () => { expect(am.needEqFunction()).toBe(false) expect(am.needNeqFunction()).toBe(false) diff --git a/tests/bindings/javascript/analyservariable.test.js b/tests/bindings/javascript/analyservariable.test.js index 802612656..aa9cbb501 100644 --- a/tests/bindings/javascript/analyservariable.test.js +++ b/tests/bindings/javascript/analyservariable.test.js @@ -40,6 +40,7 @@ describe("Analyser Variable tests", () => { expect(am.constantCount()).toBe(5) expect(am.computedConstantCount()).toBe(3) expect(am.algebraicCount()).toBe(10) + expect(am.externalCount()).toBe(0) }); test('Checking Analyser Variable type.', () => { const av = am.algebraicVariable(0) From 26ba852409a51cd7f6d94547cf4892c994f0f769 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 3 Sep 2024 14:54:34 +1200 Subject: [PATCH 51/74] Generator: make sure that NLA systems have access to external variables. --- src/api/libcellml/generatorprofile.h | 32 +- src/generator.cpp | 16 +- src/generatorprofile.cpp | 332 +++++++++++++----- src/generatorprofile_p.h | 40 ++- src/generatorprofilesha1values.h | 4 +- src/generatorprofiletools.cpp | 24 +- .../javascript/generatorprofile.test.js | 56 ++- .../bindings/python/test_generator_profile.py | 80 +++-- tests/coverage/coverage.cpp | 36 +- tests/generator/generatorprofile.cpp | 141 ++++++-- tests/resources/coverage/generator/model.c | 7 +- .../generator/model.implementation.out | 7 +- .../generator/model.modified.profile.c | 7 +- .../generator/model.modified.profile.py | 7 +- tests/resources/coverage/generator/model.out | 5 +- tests/resources/coverage/generator/model.py | 7 +- .../model.py | 1 + .../model.py | 1 + .../model.not.ordered.py | 1 + .../model.ordered.py | 1 + 20 files changed, 575 insertions(+), 230 deletions(-) diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index 12e14cc26..8608cc8d8 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -3266,10 +3266,13 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the call to the find root method is * for a differential model, as opposed to an algebraic model. + * @param withExternalVariables Whether the call to the find root method is + * for a model with external variables. * * @return The @c std::string for the call to the find root method. */ - std::string findRootCallString(bool forDifferentialModel) const; + std::string findRootCallString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the call to the find root method. @@ -3280,10 +3283,13 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the call to the find root method is * for a differential model, as opposed to an algebraic model. + * @param withExternalVariables Whether the call to the find root method is + * for a model with external variables. * @param findRootCallString The @c std::string to use for the call to the * find root method. */ void setFindRootCallString(bool forDifferentialModel, + bool withExternalVariables, const std::string &findRootCallString); /** @@ -3293,10 +3299,13 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the call to the find root method is * for a differential model, as opposed to an algebraic model. + * @param withExternalVariables Whether the call to the find root method is + * for a model with external variables. * * @return The @c std::string for the find root method. */ - std::string findRootMethodString(bool forDifferentialModel) const; + std::string findRootMethodString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the find root method. @@ -3311,10 +3320,13 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the call to the find root method is * for a differential model, as opposed to an algebraic model. + * @param withExternalVariables Whether the call to the find root method is + * for a model with external variables. * @param findRootMethodString The @c std::string to use for the find root * method. */ void setFindRootMethodString(bool forDifferentialModel, + bool withExternalVariables, const std::string &findRootMethodString); /** @@ -3324,10 +3336,13 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the call to the NLA solve method is * for a differential model, as opposed to an algebraic model. + * @param withExternalVariables Whether the call to the NLA solve method is + * for a model with external variables. * * @return The @c std::string for the call to the NLA solve method. */ - std::string nlaSolveCallString(bool forDifferentialModel) const; + std::string nlaSolveCallString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the call to the NLA solve method. @@ -3341,10 +3356,13 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the call to the NLA solve method is * for a differential model, as opposed to an algebraic model. + * @param withExternalVariables Whether the call to the NLA solve method is + * for a model with external variables. * @param nlaSolveCallString The @c std::string to use for the call to the * NLA solve method. */ void setNlaSolveCallString(bool forDifferentialModel, + bool withExternalVariables, const std::string &nlaSolveCallString); /** @@ -3354,10 +3372,13 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the call to the objective function * method is for a differential model, as opposed to an algebraic model. + * @param withExternalVariables Whether the call to the objective function + * method is for a model with external variables. * * @return The @c std::string for the objective function method. */ - std::string objectiveFunctionMethodString(bool forDifferentialModel) const; + std::string objectiveFunctionMethodString(bool forDifferentialModel, + bool withExternalVariables) const; /** * @brief Set the @c std::string for the objective function method. @@ -3369,10 +3390,13 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the call to the objective function * method is for a differential model, as opposed to an algebraic model. + * @param withExternalVariables Whether the call to the objective function + * method is for a model with external variables. * @param objectiveFunctionMethodString The @c std::string to use for the * objective function method. */ void setObjectiveFunctionMethodString(bool forDifferentialModel, + bool withExternalVariables, const std::string &objectiveFunctionMethodString); /** diff --git a/src/generator.cpp b/src/generator.cpp index 38d25b7ee..c8ce8d87c 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -755,9 +755,9 @@ void Generator::GeneratorImpl::addExternNlaSolveMethodCode() void Generator::GeneratorImpl::addNlaSystemsCode() { if (modelHasNlas() - && !mProfile->objectiveFunctionMethodString(modelHasOdes()).empty() - && !mProfile->findRootMethodString(modelHasOdes()).empty() - && !mProfile->nlaSolveCallString(modelHasOdes()).empty()) { + && !mProfile->objectiveFunctionMethodString(modelHasOdes(), mModel->hasExternalVariables()).empty() + && !mProfile->findRootMethodString(modelHasOdes(), mModel->hasExternalVariables()).empty() + && !mProfile->nlaSolveCallString(modelHasOdes(), mModel->hasExternalVariables()).empty()) { // Note: only states and algebraic variables can be computed through an NLA system. Constants, computed // constants, and external variables cannot, by definition, be computed through an NLA system. @@ -805,7 +805,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() } mCode += newLineIfNeeded() - + replace(replace(mProfile->objectiveFunctionMethodString(modelHasOdes()), + + replace(replace(mProfile->objectiveFunctionMethodString(modelHasOdes(), mModel->hasExternalVariables()), "[INDEX]", convertToString(equation->nlaSystemIndex())), "[CODE]", generateMethodBodyCode(methodBody)); @@ -829,7 +829,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() methodBody += newLineIfNeeded() + mProfile->indentString() - + replace(replace(mProfile->nlaSolveCallString(modelHasOdes()), + + replace(replace(mProfile->nlaSolveCallString(modelHasOdes(), mModel->hasExternalVariables()), "[INDEX]", convertToString(equation->nlaSystemIndex())), "[SIZE]", convertToString(variablesCount)); @@ -850,7 +850,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() } mCode += newLineIfNeeded() - + replace(replace(replace(mProfile->findRootMethodString(modelHasOdes()), + + replace(replace(replace(mProfile->findRootMethodString(modelHasOdes(), mModel->hasExternalVariables()), "[INDEX]", convertToString(equation->nlaSystemIndex())), "[SIZE]", convertToString(variablesCount)), "[CODE]", generateMethodBodyCode(methodBody)); @@ -1752,9 +1752,9 @@ std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquatio break; case AnalyserEquation::Type::NLA: - if (!mProfile->findRootCallString(modelHasOdes()).empty()) { + if (!mProfile->findRootCallString(modelHasOdes(), mModel->hasExternalVariables()).empty()) { res += mProfile->indentString() - + replace(mProfile->findRootCallString(modelHasOdes()), + + replace(mProfile->findRootCallString(modelHasOdes(), mModel->hasExternalVariables()), "[INDEX]", convertToString(equation->nlaSystemIndex())); } diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index b388edeeb..cb57072f1 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -307,7 +307,6 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " double *algebraic;\n" " double *externals;\n" "} RootFindingInfo;\n"; - mRootFindingInfoObjectFdmWoevString = "typedef struct {\n" " double voi;\n" " double *states;\n" @@ -328,43 +327,87 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mExternNlaSolveMethodString = "extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *),\n" " double *u, size_t n, void *data);\n"; - mFindRootCallFamString = "findRoot[INDEX](constants, computedConstants, algebraic);\n"; - mFindRootCallFdmString = "findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic);\n"; - mFindRootMethodFamString = "void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic)\n" - "{\n" - " RootFindingInfo rfi = { constants, computedConstants, algebraic };\n" - " double u[[SIZE]];\n" - "\n" - "[CODE]" - "}\n"; - mFindRootMethodFdmString = "void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" - "{\n" - " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic };\n" - " double u[[SIZE]];\n" - "\n" - "[CODE]" - "}\n"; - mNlaSolveCallFamString = "nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n"; - mNlaSolveCallFdmString = "nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n"; - mObjectiveFunctionMethodFamString = "void objectiveFunction[INDEX](double *u, double *f, void *data)\n" - "{\n" - " double *constants = ((RootFindingInfo *) data)->constants;\n" - " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" - " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" - "\n" - "[CODE]" - "}\n"; - mObjectiveFunctionMethodFdmString = "void objectiveFunction[INDEX](double *u, double *f, void *data)\n" - "{\n" - " double voi = ((RootFindingInfo *) data)->voi;\n" - " double *states = ((RootFindingInfo *) data)->states;\n" - " double *rates = ((RootFindingInfo *) data)->rates;\n" - " double *constants = ((RootFindingInfo *) data)->constants;\n" - " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" - " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" - "\n" - "[CODE]" - "}\n"; + + mFindRootCallFamWoevString = "findRoot[INDEX](constants, computedConstants, algebraic);\n"; + mFindRootCallFamWevString = "findRoot[INDEX](constants, computedConstants, algebraic, externals);\n"; + mFindRootCallFdmWoevString = "findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic);\n"; + mFindRootCallFdmWevString = "findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic, externals);\n"; + + mFindRootMethodFamWoevString = "void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic)\n" + "{\n" + " RootFindingInfo rfi = { constants, computedConstants, algebraic };\n" + " double u[[SIZE]];\n" + "\n" + "[CODE]" + "}\n"; + mFindRootMethodFamWevString = "void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic, double *externals)\n" + "{\n" + " RootFindingInfo rfi = { constants, computedConstants, algebraic, externals };\n" + " double u[[SIZE]];\n" + "\n" + "[CODE]" + "}\n"; + mFindRootMethodFdmWoevString = "void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + "{\n" + " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic };\n" + " double u[[SIZE]];\n" + "\n" + "[CODE]" + "}\n"; + mFindRootMethodFdmWevString = "void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals)\n" + "{\n" + " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals };\n" + " double u[[SIZE]];\n" + "\n" + "[CODE]" + "}\n"; + + mNlaSolveCallFamWoevString = "nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n"; + mNlaSolveCallFamWevString = "nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n"; + mNlaSolveCallFdmWoevString = "nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n"; + mNlaSolveCallFdmWevString = "nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n"; + + mObjectiveFunctionMethodFamWoevString = "void objectiveFunction[INDEX](double *u, double *f, void *data)\n" + "{\n" + " double *constants = ((RootFindingInfo *) data)->constants;\n" + " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" + " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" + "\n" + "[CODE]" + "}\n"; + mObjectiveFunctionMethodFamWevString = "void objectiveFunction[INDEX](double *u, double *f, void *data)\n" + "{\n" + " double *constants = ((RootFindingInfo *) data)->constants;\n" + " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" + " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" + " double *externals = ((RootFindingInfo *) data)->externals;\n" + "\n" + "[CODE]" + "}\n"; + mObjectiveFunctionMethodFdmWoevString = "void objectiveFunction[INDEX](double *u, double *f, void *data)\n" + "{\n" + " double voi = ((RootFindingInfo *) data)->voi;\n" + " double *states = ((RootFindingInfo *) data)->states;\n" + " double *rates = ((RootFindingInfo *) data)->rates;\n" + " double *constants = ((RootFindingInfo *) data)->constants;\n" + " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" + " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" + "\n" + "[CODE]" + "}\n"; + mObjectiveFunctionMethodFdmWevString = "void objectiveFunction[INDEX](double *u, double *f, void *data)\n" + "{\n" + " double voi = ((RootFindingInfo *) data)->voi;\n" + " double *states = ((RootFindingInfo *) data)->states;\n" + " double *rates = ((RootFindingInfo *) data)->rates;\n" + " double *constants = ((RootFindingInfo *) data)->constants;\n" + " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" + " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" + " double *externals = ((RootFindingInfo *) data)->externals;\n" + "\n" + "[CODE]" + "}\n"; + mUArrayString = "u"; mFArrayString = "f"; @@ -764,44 +807,81 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mRootFindingInfoObjectFamWoevString = ""; mRootFindingInfoObjectFamWevString = ""; - mRootFindingInfoObjectFdmWoevString = ""; mRootFindingInfoObjectFdmWevString = ""; mExternNlaSolveMethodString = "\n" "from nlasolver import nla_solve" "\n"; - mFindRootCallFamString = "find_root_[INDEX](constants, computed_constants, algebraic)\n"; - mFindRootCallFdmString = "find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic)\n"; - mFindRootMethodFamString = "\n" - "def find_root_[INDEX](constants, computed_constants, algebraic):\n" - " u = [nan]*[SIZE]\n" - "\n" - "[CODE]"; - mFindRootMethodFdmString = "\n" - "def find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic):\n" - " u = [nan]*[SIZE]\n" - "\n" - "[CODE]"; - mNlaSolveCallFamString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [constants, computed_constants, algebraic])\n"; - mNlaSolveCallFdmString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [voi, states, rates, constants, computed_constants, algebraic])\n"; - mObjectiveFunctionMethodFamString = "\n" - "def objective_function_[INDEX](u, f, data):\n" - " constants = data[0]\n" - " computed_constants = data[1]\n" - " algebraic = data[2]\n" - "\n" - "[CODE]"; - mObjectiveFunctionMethodFdmString = "\n" - "def objective_function_[INDEX](u, f, data):\n" - " voi = data[0]\n" - " states = data[1]\n" - " rates = data[2]\n" - " constants = data[3]\n" - " computed_constants = data[4]\n" - " algebraic = data[5]\n" - "\n" - "[CODE]"; + + mFindRootCallFamWoevString = "find_root_[INDEX](constants, computed_constants, algebraic)\n"; + mFindRootCallFamWevString = "find_root_[INDEX](constants, computed_constants, algebraic, externals)\n"; + mFindRootCallFdmWoevString = "find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic)\n"; + mFindRootCallFdmWevString = "find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic, externals)\n"; + + mFindRootMethodFamWoevString = "\n" + "def find_root_[INDEX](constants, computed_constants, algebraic):\n" + " u = [nan]*[SIZE]\n" + "\n" + "[CODE]"; + mFindRootMethodFamWevString = "\n" + "def find_root_[INDEX](constants, computed_constants, algebraic, externals):\n" + " u = [nan]*[SIZE]\n" + "\n" + "[CODE]"; + mFindRootMethodFdmWoevString = "\n" + "def find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic):\n" + " u = [nan]*[SIZE]\n" + "\n" + "[CODE]"; + mFindRootMethodFdmWevString = "\n" + "def find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic, externals):\n" + " u = [nan]*[SIZE]\n" + "\n" + "[CODE]"; + + mNlaSolveCallFamWoevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [constants, computed_constants, algebraic])\n"; + mNlaSolveCallFamWevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [constants, computed_constants, algebraic, externals])\n"; + mNlaSolveCallFdmWoevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [voi, states, rates, constants, computed_constants, algebraic])\n"; + mNlaSolveCallFdmWevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [voi, states, rates, constants, computed_constants, algebraic, externals])\n"; + + mObjectiveFunctionMethodFamWoevString = "\n" + "def objective_function_[INDEX](u, f, data):\n" + " constants = data[0]\n" + " computed_constants = data[1]\n" + " algebraic = data[2]\n" + " externals = data[3]\n" + "\n" + "[CODE]"; + mObjectiveFunctionMethodFamWevString = "\n" + "def objective_function_[INDEX](u, f, data):\n" + " constants = data[0]\n" + " computed_constants = data[1]\n" + " algebraic = data[2]\n" + "\n" + "[CODE]"; + mObjectiveFunctionMethodFdmWoevString = "\n" + "def objective_function_[INDEX](u, f, data):\n" + " voi = data[0]\n" + " states = data[1]\n" + " rates = data[2]\n" + " constants = data[3]\n" + " computed_constants = data[4]\n" + " algebraic = data[5]\n" + "\n" + "[CODE]"; + mObjectiveFunctionMethodFdmWevString = "\n" + "def objective_function_[INDEX](u, f, data):\n" + " voi = data[0]\n" + " states = data[1]\n" + " rates = data[2]\n" + " constants = data[3]\n" + " computed_constants = data[4]\n" + " algebraic = data[5]\n" + " externals = data[6]\n" + "\n" + "[CODE]"; + mUArrayString = "u"; mFArrayString = "f"; @@ -2396,79 +2476,151 @@ void GeneratorProfile::setExternNlaSolveMethodString(const std::string &externNl mPimpl->mExternNlaSolveMethodString = externNlaSolveMethodString; } -std::string GeneratorProfile::findRootCallString(bool forDifferentialModel) const +std::string GeneratorProfile::findRootCallString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { - return mPimpl->mFindRootCallFdmString; + if (withExternalVariables) { + return mPimpl->mFindRootCallFdmWevString; + } + + return mPimpl->mFindRootCallFdmWoevString; } - return mPimpl->mFindRootCallFamString; + if (withExternalVariables) { + return mPimpl->mFindRootCallFamWevString; + } + + return mPimpl->mFindRootCallFamWoevString; } void GeneratorProfile::setFindRootCallString(bool forDifferentialModel, + bool withExternalVariables, const std::string &findRootCallString) { if (forDifferentialModel) { - mPimpl->mFindRootCallFdmString = findRootCallString; + if (withExternalVariables) { + mPimpl->mFindRootCallFdmWevString = findRootCallString; + } else { + mPimpl->mFindRootCallFdmWoevString = findRootCallString; + } } else { - mPimpl->mFindRootCallFamString = findRootCallString; + if (withExternalVariables) { + mPimpl->mFindRootCallFamWevString = findRootCallString; + } else { + mPimpl->mFindRootCallFamWoevString = findRootCallString; + } } } -std::string GeneratorProfile::findRootMethodString(bool forDifferentialModel) const +std::string GeneratorProfile::findRootMethodString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { - return mPimpl->mFindRootMethodFdmString; + if (withExternalVariables) { + return mPimpl->mFindRootMethodFdmWevString; + } + + return mPimpl->mFindRootMethodFdmWoevString; + } + + if (withExternalVariables) { + return mPimpl->mFindRootMethodFamWevString; } - return mPimpl->mFindRootMethodFamString; + return mPimpl->mFindRootMethodFamWoevString; } void GeneratorProfile::setFindRootMethodString(bool forDifferentialModel, + bool withExternalVariables, const std::string &findRootMethodString) { if (forDifferentialModel) { - mPimpl->mFindRootMethodFdmString = findRootMethodString; + if (withExternalVariables) { + mPimpl->mFindRootMethodFdmWevString = findRootMethodString; + } else { + mPimpl->mFindRootMethodFdmWoevString = findRootMethodString; + } } else { - mPimpl->mFindRootMethodFamString = findRootMethodString; + if (withExternalVariables) { + mPimpl->mFindRootMethodFamWevString = findRootMethodString; + } else { + mPimpl->mFindRootMethodFamWoevString = findRootMethodString; + } } } -std::string GeneratorProfile::nlaSolveCallString(bool forDifferentialModel) const +std::string GeneratorProfile::nlaSolveCallString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { - return mPimpl->mNlaSolveCallFdmString; + if (withExternalVariables) { + return mPimpl->mNlaSolveCallFdmWevString; + } + + return mPimpl->mNlaSolveCallFdmWoevString; + } + + if (withExternalVariables) { + return mPimpl->mNlaSolveCallFamWevString; } - return mPimpl->mNlaSolveCallFamString; + return mPimpl->mNlaSolveCallFamWoevString; } void GeneratorProfile::setNlaSolveCallString(bool forDifferentialModel, + bool withExternalVariables, const std::string &nlaSolveCallString) { if (forDifferentialModel) { - mPimpl->mNlaSolveCallFdmString = nlaSolveCallString; + if (withExternalVariables) { + mPimpl->mNlaSolveCallFdmWevString = nlaSolveCallString; + } else { + mPimpl->mNlaSolveCallFdmWoevString = nlaSolveCallString; + } } else { - mPimpl->mNlaSolveCallFamString = nlaSolveCallString; + if (withExternalVariables) { + mPimpl->mNlaSolveCallFamWevString = nlaSolveCallString; + } else { + mPimpl->mNlaSolveCallFamWoevString = nlaSolveCallString; + } } } -std::string GeneratorProfile::objectiveFunctionMethodString(bool forDifferentialModel) const +std::string GeneratorProfile::objectiveFunctionMethodString(bool forDifferentialModel, + bool withExternalVariables) const { if (forDifferentialModel) { - return mPimpl->mObjectiveFunctionMethodFdmString; + if (withExternalVariables) { + return mPimpl->mObjectiveFunctionMethodFdmWevString; + } + + return mPimpl->mObjectiveFunctionMethodFdmWoevString; } - return mPimpl->mObjectiveFunctionMethodFamString; + if (withExternalVariables) { + return mPimpl->mObjectiveFunctionMethodFamWevString; + } + + return mPimpl->mObjectiveFunctionMethodFamWoevString; } void GeneratorProfile::setObjectiveFunctionMethodString(bool forDifferentialModel, + bool withExternalVariables, const std::string &objectiveFunctionMethodString) { if (forDifferentialModel) { - mPimpl->mObjectiveFunctionMethodFdmString = objectiveFunctionMethodString; + if (withExternalVariables) { + mPimpl->mObjectiveFunctionMethodFdmWevString = objectiveFunctionMethodString; + } else { + mPimpl->mObjectiveFunctionMethodFdmWoevString = objectiveFunctionMethodString; + } } else { - mPimpl->mObjectiveFunctionMethodFamString = objectiveFunctionMethodString; + if (withExternalVariables) { + mPimpl->mObjectiveFunctionMethodFamWevString = objectiveFunctionMethodString; + } else { + mPimpl->mObjectiveFunctionMethodFamWoevString = objectiveFunctionMethodString; + } } } diff --git a/src/generatorprofile_p.h b/src/generatorprofile_p.h index fda7cf543..0a44b83d0 100644 --- a/src/generatorprofile_p.h +++ b/src/generatorprofile_p.h @@ -227,19 +227,31 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mRootFindingInfoObjectFamWoevString; std::string mRootFindingInfoObjectFamWevString; - std::string mRootFindingInfoObjectFdmWoevString; std::string mRootFindingInfoObjectFdmWevString; std::string mExternNlaSolveMethodString; - std::string mFindRootCallFamString; - std::string mFindRootCallFdmString; - std::string mFindRootMethodFamString; - std::string mFindRootMethodFdmString; - std::string mNlaSolveCallFamString; - std::string mNlaSolveCallFdmString; - std::string mObjectiveFunctionMethodFamString; - std::string mObjectiveFunctionMethodFdmString; + + std::string mFindRootCallFamWoevString; + std::string mFindRootCallFamWevString; + std::string mFindRootCallFdmWoevString; + std::string mFindRootCallFdmWevString; + + std::string mFindRootMethodFamWoevString; + std::string mFindRootMethodFamWevString; + std::string mFindRootMethodFdmWoevString; + std::string mFindRootMethodFdmWevString; + + std::string mNlaSolveCallFamWoevString; + std::string mNlaSolveCallFamWevString; + std::string mNlaSolveCallFdmWoevString; + std::string mNlaSolveCallFdmWevString; + + std::string mObjectiveFunctionMethodFamWoevString; + std::string mObjectiveFunctionMethodFamWevString; + std::string mObjectiveFunctionMethodFdmWoevString; + std::string mObjectiveFunctionMethodFdmWevString; + std::string mUArrayString; std::string mFArrayString; @@ -277,15 +289,13 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mImplementationComputeRatesMethodWevString; std::string mInterfaceComputeVariablesMethodFamWoevString; - std::string mImplementationComputeVariablesMethodFamWoevString; - std::string mInterfaceComputeVariablesMethodFamWevString; - std::string mImplementationComputeVariablesMethodFamWevString; - std::string mInterfaceComputeVariablesMethodFdmWoevString; - std::string mImplementationComputeVariablesMethodFdmWoevString; - std::string mInterfaceComputeVariablesMethodFdmWevString; + + std::string mImplementationComputeVariablesMethodFamWoevString; + std::string mImplementationComputeVariablesMethodFamWevString; + std::string mImplementationComputeVariablesMethodFdmWoevString; std::string mImplementationComputeVariablesMethodFdmWevString; std::string mEmptyMethodString; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 1c6ba04d8..8c6df4ed7 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "d3c84f25e69c62eaf1a154bf75d4394185cf7e23"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "06014d14cb0b183d9ba4952c56eb36388da5de28"; +static const char C_GENERATOR_PROFILE_SHA1[] = "f0d3add475025d2d4b805747828dbaf2f1345b2f"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "704a899325e7a0ad40c0275ff5dcd5586ad64bf5"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index c85fe9411..9b4d0086d 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -496,14 +496,22 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile + generatorProfile->rootFindingInfoObjectString(true, false) + generatorProfile->rootFindingInfoObjectString(true, true) + generatorProfile->externNlaSolveMethodString() - + generatorProfile->findRootCallString(false) - + generatorProfile->findRootCallString(true) - + generatorProfile->findRootMethodString(false) - + generatorProfile->findRootMethodString(true) - + generatorProfile->nlaSolveCallString(false) - + generatorProfile->nlaSolveCallString(true) - + generatorProfile->objectiveFunctionMethodString(false) - + generatorProfile->objectiveFunctionMethodString(true) + + generatorProfile->findRootCallString(false, false) + + generatorProfile->findRootCallString(false, true) + + generatorProfile->findRootCallString(true, false) + + generatorProfile->findRootCallString(true, true) + + generatorProfile->findRootMethodString(false, false) + + generatorProfile->findRootMethodString(false, true) + + generatorProfile->findRootMethodString(true, false) + + generatorProfile->findRootMethodString(true, true) + + generatorProfile->nlaSolveCallString(false, false) + + generatorProfile->nlaSolveCallString(false, true) + + generatorProfile->nlaSolveCallString(true, false) + + generatorProfile->nlaSolveCallString(true, true) + + generatorProfile->objectiveFunctionMethodString(false, false) + + generatorProfile->objectiveFunctionMethodString(false, true) + + generatorProfile->objectiveFunctionMethodString(true, false) + + generatorProfile->objectiveFunctionMethodString(true, true) + generatorProfile->uArrayString() + generatorProfile->fArrayString(); diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index 1b728eec3..e3c40bfe4 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -840,38 +840,62 @@ describe("GeneratorProfile tests", () => { test("Checking GeneratorProfile.findRootCallString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setFindRootCallString(false, "something") - expect(x.findRootCallString(false)).toBe("something") + x.setFindRootCallString(false, false, "something") + expect(x.findRootCallString(false, false)).toBe("something") - x.setFindRootCallString(true, "something") - expect(x.findRootCallString(true)).toBe("something") + x.setFindRootCallString(false, true, "something") + expect(x.findRootCallString(false, true)).toBe("something") + + x.setFindRootCallString(true, false, "something") + expect(x.findRootCallString(true, false)).toBe("something") + + x.setFindRootCallString(true, true, "something") + expect(x.findRootCallString(true, true)).toBe("something") }); test("Checking GeneratorProfile.findRootMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setFindRootMethodString(false, "something") - expect(x.findRootMethodString(false)).toBe("something") + x.setFindRootMethodString(false, false, "something") + expect(x.findRootMethodString(false, false)).toBe("something") + + x.setFindRootMethodString(false, true, "something") + expect(x.findRootMethodString(false, true)).toBe("something") + + x.setFindRootMethodString(true, false, "something") + expect(x.findRootMethodString(true, false)).toBe("something") - x.setFindRootMethodString(true, "something") - expect(x.findRootMethodString(true)).toBe("something") + x.setFindRootMethodString(true, true, "something") + expect(x.findRootMethodString(true, true)).toBe("something") }); test("Checking GeneratorProfile.nlaSolveCallString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setNlaSolveCallString(false, "something") - expect(x.nlaSolveCallString(false)).toBe("something") + x.setNlaSolveCallString(false, false, "something") + expect(x.nlaSolveCallString(false, false)).toBe("something") - x.setNlaSolveCallString(true, "something") - expect(x.nlaSolveCallString(true)).toBe("something") + x.setNlaSolveCallString(false, true, "something") + expect(x.nlaSolveCallString(false, true)).toBe("something") + + x.setNlaSolveCallString(true, false, "something") + expect(x.nlaSolveCallString(true, false)).toBe("something") + + x.setNlaSolveCallString(true, true, "something") + expect(x.nlaSolveCallString(true, true)).toBe("something") }); test("Checking GeneratorProfile.objectiveFunctionMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setObjectiveFunctionMethodString(false, "something") - expect(x.objectiveFunctionMethodString(false)).toBe("something") + x.setObjectiveFunctionMethodString(false, false, "something") + expect(x.objectiveFunctionMethodString(false, false)).toBe("something") + + x.setObjectiveFunctionMethodString(false, true, "something") + expect(x.objectiveFunctionMethodString(false, true)).toBe("something") + + x.setObjectiveFunctionMethodString(true, false, "something") + expect(x.objectiveFunctionMethodString(true, false)).toBe("something") - x.setObjectiveFunctionMethodString(true, "something") - expect(x.objectiveFunctionMethodString(true)).toBe("something") + x.setObjectiveFunctionMethodString(true, true, "something") + expect(x.objectiveFunctionMethodString(true, true)).toBe("something") }); test("Checking GeneratorProfile.uArrayString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index b3bb6ad3a..54befa012 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -1738,52 +1738,84 @@ def test_find_root_call_string(self): g = GeneratorProfile() - self.assertEqual('findRoot[INDEX](constants, computedConstants, algebraic);\n', g.findRootCallString(False)) - g.setFindRootCallString(False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(False)) + self.assertEqual('findRoot[INDEX](constants, computedConstants, algebraic);\n', g.findRootCallString(False, False)) + g.setFindRootCallString(False, False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(False, False)) - self.assertEqual('findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic);\n', g.findRootCallString(True)) - g.setFindRootCallString(True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(True)) + self.assertEqual('findRoot[INDEX](constants, computedConstants, algebraic, externals);\n', g.findRootCallString(False, True)) + g.setFindRootCallString(False, True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(False, True)) + + self.assertEqual('findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic);\n', g.findRootCallString(True, False)) + g.setFindRootCallString(True, False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(True, False)) + + self.assertEqual('findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic, externals);\n', g.findRootCallString(True, True)) + g.setFindRootCallString(True, True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(True, True)) def test_find_root_method_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic)\n{\n RootFindingInfo rfi = { constants, computedConstants, algebraic };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(False)) - g.setFindRootMethodString(False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(False)) + self.assertEqual('void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic)\n{\n RootFindingInfo rfi = { constants, computedConstants, algebraic };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(False, False)) + g.setFindRootMethodString(False, False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(False, False)) + + self.assertEqual('void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic, double *externals)\n{\n RootFindingInfo rfi = { constants, computedConstants, algebraic, externals };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(False, True)) + g.setFindRootMethodString(False, True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(False, True)) + + self.assertEqual('void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(True, False)) + g.setFindRootMethodString(True, False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(True, False)) - self.assertEqual('void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(True)) - g.setFindRootMethodString(True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(True)) + self.assertEqual('void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals)\n{\n RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(True, True)) + g.setFindRootMethodString(True, True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(True, True)) def test_nla_solve_call_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n', g.nlaSolveCallString(False)) - g.setNlaSolveCallString(False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.nlaSolveCallString(False)) + self.assertEqual('nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n', g.nlaSolveCallString(False, False)) + g.setNlaSolveCallString(False, False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.nlaSolveCallString(False, False)) - self.assertEqual('nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n', g.nlaSolveCallString(True)) - g.setNlaSolveCallString(True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.nlaSolveCallString(True)) + self.assertEqual('nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n', g.nlaSolveCallString(False, True)) + g.setNlaSolveCallString(False, True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.nlaSolveCallString(False, True)) + + self.assertEqual('nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n', g.nlaSolveCallString(True, False)) + g.setNlaSolveCallString(True, False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.nlaSolveCallString(True, False)) + + self.assertEqual('nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n', g.nlaSolveCallString(True, True)) + g.setNlaSolveCallString(True, True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.nlaSolveCallString(True, True)) def test_objective_function_method_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n\n[CODE]}\n', g.objectiveFunctionMethodString(False)) - g.setObjectiveFunctionMethodString(False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(False)) + self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n\n[CODE]}\n', g.objectiveFunctionMethodString(False, False)) + g.setObjectiveFunctionMethodString(False, False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(False, False)) + + self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n double *externals = ((RootFindingInfo *) data)->externals;\n\n[CODE]}\n', g.objectiveFunctionMethodString(False, True)) + g.setObjectiveFunctionMethodString(False, True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(False, True)) + + self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double voi = ((RootFindingInfo *) data)->voi;\n double *states = ((RootFindingInfo *) data)->states;\n double *rates = ((RootFindingInfo *) data)->rates;\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n\n[CODE]}\n', g.objectiveFunctionMethodString(True, False)) + g.setObjectiveFunctionMethodString(True, False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(True, False)) - self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double voi = ((RootFindingInfo *) data)->voi;\n double *states = ((RootFindingInfo *) data)->states;\n double *rates = ((RootFindingInfo *) data)->rates;\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n\n[CODE]}\n', g.objectiveFunctionMethodString(True)) - g.setObjectiveFunctionMethodString(True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(True)) + self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double voi = ((RootFindingInfo *) data)->voi;\n double *states = ((RootFindingInfo *) data)->states;\n double *rates = ((RootFindingInfo *) data)->rates;\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n double *externals = ((RootFindingInfo *) data)->externals;\n\n[CODE]}\n', g.objectiveFunctionMethodString(True, True)) + g.setObjectiveFunctionMethodString(True, True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(True, True)) def test_u_array_string(self): from libcellml import GeneratorProfile diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index c0ff65534..4e71511c8 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -893,8 +893,10 @@ TEST(Coverage, generator) profile->setInterfaceHeaderString(""); profile->setMaxFunctionString(""); profile->setMinFunctionString(""); - profile->setObjectiveFunctionMethodString(false, ""); - profile->setObjectiveFunctionMethodString(true, ""); + profile->setObjectiveFunctionMethodString(false, false, ""); + profile->setObjectiveFunctionMethodString(false, true, ""); + profile->setObjectiveFunctionMethodString(true, false, ""); + profile->setObjectiveFunctionMethodString(true, true, ""); profile->setSecFunctionString(""); profile->setSechFunctionString(""); profile->setVariableInfoEntryString(""); @@ -904,10 +906,14 @@ TEST(Coverage, generator) profile->setArrayElementSeparatorString(""); profile->setCommentString("xxx"); - profile->setFindRootMethodString(false, ""); - profile->setFindRootMethodString(true, ""); - profile->setObjectiveFunctionMethodString(false, "xxx"); - profile->setObjectiveFunctionMethodString(true, "xxx"); + profile->setFindRootMethodString(false, false, ""); + profile->setFindRootMethodString(false, true, ""); + profile->setFindRootMethodString(true, false, ""); + profile->setFindRootMethodString(true, true, ""); + profile->setObjectiveFunctionMethodString(false, false, "xxx"); + profile->setObjectiveFunctionMethodString(false, true, "xxx"); + profile->setObjectiveFunctionMethodString(true, false, "xxx"); + profile->setObjectiveFunctionMethodString(true, true, "xxx"); profile->setOriginCommentString(""); profile->setVariableInfoEntryString("xxx"); @@ -915,12 +921,18 @@ TEST(Coverage, generator) profile->setArrayElementSeparatorString("xxx"); profile->setExternNlaSolveMethodString(""); - profile->setFindRootMethodString(false, "xxx"); - profile->setFindRootMethodString(true, "xxx"); - profile->setFindRootCallString(false, ""); - profile->setFindRootCallString(true, ""); - profile->setNlaSolveCallString(false, ""); - profile->setNlaSolveCallString(true, ""); + profile->setFindRootMethodString(false, false, "xxx"); + profile->setFindRootMethodString(false, true, "xxx"); + profile->setFindRootMethodString(true, false, "xxx"); + profile->setFindRootMethodString(true, true, "xxx"); + profile->setFindRootCallString(false, false, ""); + profile->setFindRootCallString(false, true, ""); + profile->setFindRootCallString(true, false, ""); + profile->setFindRootCallString(true, true, ""); + profile->setNlaSolveCallString(false, false, ""); + profile->setNlaSolveCallString(false, true, ""); + profile->setNlaSolveCallString(true, false, ""); + profile->setNlaSolveCallString(true, true, ""); generator->implementationCode(); diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index c61172e51..1b8071fbf 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -384,9 +384,13 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) " double *u, size_t n, void *data);\n", generatorProfile->externNlaSolveMethodString()); EXPECT_EQ("findRoot[INDEX](constants, computedConstants, algebraic);\n", - generatorProfile->findRootCallString(false)); + generatorProfile->findRootCallString(false, false)); + EXPECT_EQ("findRoot[INDEX](constants, computedConstants, algebraic, externals);\n", + generatorProfile->findRootCallString(false, true)); EXPECT_EQ("findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic);\n", - generatorProfile->findRootCallString(true)); + generatorProfile->findRootCallString(true, false)); + EXPECT_EQ("findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic, externals);\n", + generatorProfile->findRootCallString(true, true)); EXPECT_EQ("void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic)\n" "{\n" " RootFindingInfo rfi = { constants, computedConstants, algebraic };\n" @@ -394,7 +398,15 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "\n" "[CODE]" "}\n", - generatorProfile->findRootMethodString(false)); + generatorProfile->findRootMethodString(false, false)); + EXPECT_EQ("void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic, double *externals)\n" + "{\n" + " RootFindingInfo rfi = { constants, computedConstants, algebraic, externals };\n" + " double u[[SIZE]];\n" + "\n" + "[CODE]" + "}\n", + generatorProfile->findRootMethodString(false, true)); EXPECT_EQ("void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" "{\n" " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic };\n" @@ -402,11 +414,23 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "\n" "[CODE]" "}\n", - generatorProfile->findRootMethodString(true)); + generatorProfile->findRootMethodString(true, false)); + EXPECT_EQ("void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals)\n" + "{\n" + " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals };\n" + " double u[[SIZE]];\n" + "\n" + "[CODE]" + "}\n", + generatorProfile->findRootMethodString(true, true)); + EXPECT_EQ("nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n", + generatorProfile->nlaSolveCallString(false, false)); + EXPECT_EQ("nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n", + generatorProfile->nlaSolveCallString(false, true)); EXPECT_EQ("nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n", - generatorProfile->nlaSolveCallString(false)); + generatorProfile->nlaSolveCallString(true, false)); EXPECT_EQ("nlaSolve(objectiveFunction[INDEX], u, [SIZE], &rfi);\n", - generatorProfile->nlaSolveCallString(true)); + generatorProfile->nlaSolveCallString(true, true)); EXPECT_EQ("void objectiveFunction[INDEX](double *u, double *f, void *data)\n" "{\n" " double *constants = ((RootFindingInfo *) data)->constants;\n" @@ -415,7 +439,29 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "\n" "[CODE]" "}\n", - generatorProfile->objectiveFunctionMethodString(false)); + generatorProfile->objectiveFunctionMethodString(false, false)); + EXPECT_EQ("void objectiveFunction[INDEX](double *u, double *f, void *data)\n" + "{\n" + " double *constants = ((RootFindingInfo *) data)->constants;\n" + " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" + " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" + " double *externals = ((RootFindingInfo *) data)->externals;\n" + "\n" + "[CODE]" + "}\n", + generatorProfile->objectiveFunctionMethodString(false, true)); + EXPECT_EQ("void objectiveFunction[INDEX](double *u, double *f, void *data)\n" + "{\n" + " double voi = ((RootFindingInfo *) data)->voi;\n" + " double *states = ((RootFindingInfo *) data)->states;\n" + " double *rates = ((RootFindingInfo *) data)->rates;\n" + " double *constants = ((RootFindingInfo *) data)->constants;\n" + " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" + " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" + "\n" + "[CODE]" + "}\n", + generatorProfile->objectiveFunctionMethodString(true, false)); EXPECT_EQ("void objectiveFunction[INDEX](double *u, double *f, void *data)\n" "{\n" " double voi = ((RootFindingInfo *) data)->voi;\n" @@ -424,10 +470,11 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) " double *constants = ((RootFindingInfo *) data)->constants;\n" " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" + " double *externals = ((RootFindingInfo *) data)->externals;\n" "\n" "[CODE]" "}\n", - generatorProfile->objectiveFunctionMethodString(true)); + generatorProfile->objectiveFunctionMethodString(true, true)); EXPECT_EQ("u", generatorProfile->uArrayString()); EXPECT_EQ("f", @@ -960,15 +1007,29 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setRootFindingInfoObjectString(false, true, value); generatorProfile->setRootFindingInfoObjectString(true, false, value); generatorProfile->setRootFindingInfoObjectString(true, true, value); + generatorProfile->setExternNlaSolveMethodString(value); - generatorProfile->setFindRootCallString(false, value); - generatorProfile->setFindRootCallString(true, value); - generatorProfile->setFindRootMethodString(false, value); - generatorProfile->setFindRootMethodString(true, value); - generatorProfile->setNlaSolveCallString(false, value); - generatorProfile->setNlaSolveCallString(true, value); - generatorProfile->setObjectiveFunctionMethodString(false, value); - generatorProfile->setObjectiveFunctionMethodString(true, value); + + generatorProfile->setFindRootCallString(false, false, value); + generatorProfile->setFindRootCallString(false, true, value); + generatorProfile->setFindRootCallString(true, false, value); + generatorProfile->setFindRootCallString(true, true, value); + + generatorProfile->setFindRootMethodString(false, false, value); + generatorProfile->setFindRootMethodString(false, true, value); + generatorProfile->setFindRootMethodString(true, false, value); + generatorProfile->setFindRootMethodString(true, true, value); + + generatorProfile->setNlaSolveCallString(false, false, value); + generatorProfile->setNlaSolveCallString(false, true, value); + generatorProfile->setNlaSolveCallString(true, false, value); + generatorProfile->setNlaSolveCallString(true, true, value); + + generatorProfile->setObjectiveFunctionMethodString(false, false, value); + generatorProfile->setObjectiveFunctionMethodString(false, true, value); + generatorProfile->setObjectiveFunctionMethodString(true, false, value); + generatorProfile->setObjectiveFunctionMethodString(true, true, value); + generatorProfile->setUArrayString(value); generatorProfile->setFArrayString(value); @@ -991,30 +1052,28 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setImplementationDeleteArrayMethodString(value); generatorProfile->setInterfaceInitialiseVariablesMethodString(false, value); - generatorProfile->setImplementationInitialiseVariablesMethodString(false, value); - generatorProfile->setInterfaceInitialiseVariablesMethodString(true, value); + + generatorProfile->setImplementationInitialiseVariablesMethodString(false, value); generatorProfile->setImplementationInitialiseVariablesMethodString(true, value); generatorProfile->setInterfaceComputeComputedConstantsMethodString(value); generatorProfile->setImplementationComputeComputedConstantsMethodString(value); generatorProfile->setInterfaceComputeRatesMethodString(false, value); - generatorProfile->setImplementationComputeRatesMethodString(false, value); - generatorProfile->setInterfaceComputeRatesMethodString(true, value); + + generatorProfile->setImplementationComputeRatesMethodString(false, value); generatorProfile->setImplementationComputeRatesMethodString(true, value); generatorProfile->setInterfaceComputeVariablesMethodString(false, false, value); - generatorProfile->setImplementationComputeVariablesMethodString(false, false, value); - generatorProfile->setInterfaceComputeVariablesMethodString(false, true, value); - generatorProfile->setImplementationComputeVariablesMethodString(false, true, value); - generatorProfile->setInterfaceComputeVariablesMethodString(true, false, value); - generatorProfile->setImplementationComputeVariablesMethodString(true, false, value); - generatorProfile->setInterfaceComputeVariablesMethodString(true, true, value); + + generatorProfile->setImplementationComputeVariablesMethodString(false, false, value); + generatorProfile->setImplementationComputeVariablesMethodString(false, true, value); + generatorProfile->setImplementationComputeVariablesMethodString(true, false, value); generatorProfile->setImplementationComputeVariablesMethodString(true, true, value); generatorProfile->setEmptyMethodString(value); @@ -1103,15 +1162,29 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->rootFindingInfoObjectString(false, true)); EXPECT_EQ(value, generatorProfile->rootFindingInfoObjectString(true, false)); EXPECT_EQ(value, generatorProfile->rootFindingInfoObjectString(true, true)); + EXPECT_EQ(value, generatorProfile->externNlaSolveMethodString()); - EXPECT_EQ(value, generatorProfile->findRootCallString(false)); - EXPECT_EQ(value, generatorProfile->findRootCallString(true)); - EXPECT_EQ(value, generatorProfile->findRootMethodString(false)); - EXPECT_EQ(value, generatorProfile->findRootMethodString(true)); - EXPECT_EQ(value, generatorProfile->nlaSolveCallString(false)); - EXPECT_EQ(value, generatorProfile->nlaSolveCallString(true)); - EXPECT_EQ(value, generatorProfile->objectiveFunctionMethodString(false)); - EXPECT_EQ(value, generatorProfile->objectiveFunctionMethodString(true)); + + EXPECT_EQ(value, generatorProfile->findRootCallString(false, false)); + EXPECT_EQ(value, generatorProfile->findRootCallString(false, true)); + EXPECT_EQ(value, generatorProfile->findRootCallString(true, false)); + EXPECT_EQ(value, generatorProfile->findRootCallString(true, true)); + + EXPECT_EQ(value, generatorProfile->findRootMethodString(false, false)); + EXPECT_EQ(value, generatorProfile->findRootMethodString(false, true)); + EXPECT_EQ(value, generatorProfile->findRootMethodString(true, false)); + EXPECT_EQ(value, generatorProfile->findRootMethodString(true, true)); + + EXPECT_EQ(value, generatorProfile->nlaSolveCallString(false, false)); + EXPECT_EQ(value, generatorProfile->nlaSolveCallString(false, true)); + EXPECT_EQ(value, generatorProfile->nlaSolveCallString(true, false)); + EXPECT_EQ(value, generatorProfile->nlaSolveCallString(true, true)); + + EXPECT_EQ(value, generatorProfile->objectiveFunctionMethodString(false, false)); + EXPECT_EQ(value, generatorProfile->objectiveFunctionMethodString(false, true)); + EXPECT_EQ(value, generatorProfile->objectiveFunctionMethodString(true, false)); + EXPECT_EQ(value, generatorProfile->objectiveFunctionMethodString(true, true)); + EXPECT_EQ(value, generatorProfile->uArrayString()); EXPECT_EQ(value, generatorProfile->fArrayString()); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 7560c1283..f5a5cb554 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -403,6 +403,7 @@ void objectiveFunction0(double *u, double *f, void *data) double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; algebraic[0] = u[0]; algebraic[1] = u[1]; @@ -411,9 +412,9 @@ void objectiveFunction0(double *u, double *f, void *data) f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; double u[2]; u[0] = algebraic[0]; @@ -650,5 +651,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - findRoot0(voi, states, rates, constants, computedConstants, algebraic); + findRoot0(voi, states, rates, constants, computedConstants, algebraic, externals); } diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index 3f78260f6..e08d72c8b 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -162,6 +162,7 @@ void objectiveFunction0(double *u, double *f, void *data) double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; algebraic[0] = u[0]; algebraic[1] = u[1]; @@ -170,9 +171,9 @@ void objectiveFunction0(double *u, double *f, void *data) f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; double u[2]; u[0] = algebraic[0]; @@ -409,5 +410,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - findRoot0(voi, states, rates, constants, computedConstants, algebraic); + findRoot0(voi, states, rates, constants, computedConstants, algebraic, externals); } diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index a539d5704..ad04e9ad0 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -403,6 +403,7 @@ void objectiveFunction0(double *u, double *f, void *data) double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; algebraic[0] = u[0]; algebraic[1] = u[1]; @@ -411,9 +412,9 @@ void objectiveFunction0(double *u, double *f, void *data) f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; double u[2]; u[0] = algebraic[0]; @@ -650,5 +651,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - findRoot0(voi, states, rates, constants, computedConstants, algebraic); + findRoot0(voi, states, rates, constants, computedConstants, algebraic, externals); } diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index a953afffa..f6a8f403f 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -373,6 +373,7 @@ def objective_function_0(u, f, data): constants = data[3] computed_constants = data[4] algebraic = data[5] + externals = data[6] algebraic[0] = u[0] algebraic[1] = u[1] @@ -381,13 +382,13 @@ def objective_function_0(u, f, data): f[1] = algebraic[0]-algebraic[1]-(computed_constants[197]+computed_constants[198]) -def find_root_0(voi, states, rates, constants, computed_constants, algebraic): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals): u = [nan]*2 u[0] = algebraic[0] u[1] = algebraic[1] - u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic, externals]) algebraic[0] = u[0] algebraic[1] = u[1] @@ -614,4 +615,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - find_root_0(voi, states, rates, constants, computed_constants, algebraic) + find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals) diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index 6391e30e4..1d349599c 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -99,6 +99,7 @@ void objectiveFunction0(double *u, double *f, void *data) double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; algebraic[0] = u[0]; algebraic[1] = u[1]; @@ -107,9 +108,9 @@ void objectiveFunction0(double *u, double *f, void *data) f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; double u[2]; u[0] = algebraic[0]; diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 1fff7c331..06e4823cf 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -373,6 +373,7 @@ def objective_function_0(u, f, data): constants = data[3] computed_constants = data[4] algebraic = data[5] + externals = data[6] algebraic[0] = u[0] algebraic[1] = u[1] @@ -381,13 +382,13 @@ def objective_function_0(u, f, data): f[1] = algebraic[0]-algebraic[1]-(computed_constants[197]+computed_constants[198]) -def find_root_0(voi, states, rates, constants, computed_constants, algebraic): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals): u = [nan]*2 u[0] = algebraic[0] u[1] = algebraic[1] - u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic, externals]) algebraic[0] = u[0] algebraic[1] = u[1] @@ -614,4 +615,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - find_root_0(voi, states, rates, constants, computed_constants, algebraic) + find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 0e3d3346d..7d7cc6c89 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -44,6 +44,7 @@ def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] algebraic = data[2] + externals = data[3] algebraic[0] = u[0] diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 64d958922..fbea6af5a 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -43,6 +43,7 @@ def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] algebraic = data[2] + externals = data[3] algebraic[0] = u[0] algebraic[1] = u[1] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 9398a2d15..e0fce8b03 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -46,6 +46,7 @@ def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] algebraic = data[2] + externals = data[3] algebraic[2] = u[0] algebraic[1] = u[1] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 780f9aac8..62bfe3cd5 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -46,6 +46,7 @@ def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] algebraic = data[2] + externals = data[3] algebraic[0] = u[0] algebraic[1] = u[1] From 68c98950136581418998186f5789a8afb2454d59 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 5 Sep 2024 20:48:04 +1200 Subject: [PATCH 52/74] Generator: fixed a small issue with our Python profile. --- src/generatorprofile.cpp | 2 +- src/generatorprofilesha1values.h | 2 +- .../algebraic_eqn_with_one_non_isolated_unknown/model.py | 1 - .../algebraic_system_with_three_linked_unknowns/model.py | 1 - .../model.not.ordered.py | 1 - .../algebraic_system_with_various_dependencies/model.ordered.py | 1 - 6 files changed, 2 insertions(+), 6 deletions(-) diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index cb57072f1..2d1a11d2f 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -850,7 +850,6 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " constants = data[0]\n" " computed_constants = data[1]\n" " algebraic = data[2]\n" - " externals = data[3]\n" "\n" "[CODE]"; mObjectiveFunctionMethodFamWevString = "\n" @@ -858,6 +857,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " constants = data[0]\n" " computed_constants = data[1]\n" " algebraic = data[2]\n" + " externals = data[3]\n" "\n" "[CODE]"; mObjectiveFunctionMethodFdmWoevString = "\n" diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 8c6df4ed7..1bb721da2 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -25,6 +25,6 @@ namespace libcellml { * See docs/dev_utilities.rst for further information. */ static const char C_GENERATOR_PROFILE_SHA1[] = "f0d3add475025d2d4b805747828dbaf2f1345b2f"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "704a899325e7a0ad40c0275ff5dcd5586ad64bf5"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "35838d23a1b89fe47293f75e2684ba6d230cf4a8"; } // namespace libcellml diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 7d7cc6c89..0e3d3346d 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -44,7 +44,6 @@ def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] algebraic = data[2] - externals = data[3] algebraic[0] = u[0] diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index fbea6af5a..64d958922 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -43,7 +43,6 @@ def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] algebraic = data[2] - externals = data[3] algebraic[0] = u[0] algebraic[1] = u[1] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index e0fce8b03..9398a2d15 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -46,7 +46,6 @@ def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] algebraic = data[2] - externals = data[3] algebraic[2] = u[0] algebraic[1] = u[1] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 62bfe3cd5..780f9aac8 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -46,7 +46,6 @@ def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] algebraic = data[2] - externals = data[3] algebraic[0] = u[0] algebraic[1] = u[1] From f0957e0890ad141252caf040ef45d1bef725e999 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 6 Sep 2024 10:33:32 +1200 Subject: [PATCH 53/74] Tests: added a test to generate some code for the DAE version of the HH52 model with various external variables. --- tests/generator/generator.cpp | 45 +- .../model.dae.external.c | 562 ++++++++++++++++++ .../model.dae.external.h | 42 ++ .../model.dae.external.py | 478 +++++++++++++++ 4 files changed, 1126 insertions(+), 1 deletion(-) create mode 100644 tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c create mode 100644 tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h create mode 100644 tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index e6e327a4a..bfb2d35c8 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -1599,7 +1599,7 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952WithVariousExternalVariables) EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.external.py", generator->implementationCode()); } -TEST(Generator, hodgkinHuxleySquidAxonModel1952Nla) +TEST(Generator, hodgkinHuxleySquidAxonModel195Dae) { // Same as the hodgkinHuxleySquidAxonModel1952 test, except that all the // algebraic equations are to be computed using NLA systems of one equation. @@ -1634,6 +1634,49 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952Nla) EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py", generator->implementationCode()); } +TEST(Generator, hodgkinHuxleySquidAxonModel1952DaeWithVariousExternalVariables) +{ + // Same as hodgkinHuxleySquidAxonModel1952WithVariousExternalVariables but with the DAE version of the HH52 model. + + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + auto potassium_channel_n_gate_alpha_n = model->component("potassium_channel_n_gate")->variable("alpha_n"); + auto external_sodium_channel_i_Na = libcellml::AnalyserExternalVariable::create(model->component("sodium_channel")->variable("i_Na")); + + external_sodium_channel_i_Na->addDependency(potassium_channel_n_gate_alpha_n); + external_sodium_channel_i_Na->addDependency(model->component("sodium_channel_h_gate")->variable("h")); + + analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(model->component("membrane")->variable("V"))); + analyser->addExternalVariable(external_sodium_channel_i_Na); + analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(potassium_channel_n_gate_alpha_n)); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->model(); + auto generator = libcellml::Generator::create(); + + generator->setModel(analyserModel); + + auto profile = generator->profile(); + + profile->setInterfaceFileNameString("model.dae.external.h"); + + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h", generator->interfaceCode()); + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c", generator->implementationCode()); + + profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + generator->setProfile(profile); + + EXPECT_EQ_FILE_CONTENTS("generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py", generator->implementationCode()); +} + TEST(Generator, nobleModel1962) { auto parser = libcellml::Parser::create(); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c new file mode 100644 index 000000000..3d179b3e0 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c @@ -0,0 +1,562 @@ +/* The content of this file was generated using the C profile of libCellML 0.5.0. */ + +#include "model.dae.external.h" + +#include +#include + +const char VERSION[] = "0.6.0"; +const char LIBCELLML_VERSION[] = "0.5.0"; + +const size_t STATE_COUNT = 3; +const size_t CONSTANT_COUNT = 5; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_COUNT = 11; +const size_t EXTERNAL_COUNT = 3; + +const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, + {"n", "dimensionless", "potassium_channel_n_gate"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"Cm", "microF_per_cm2", "membrane"}, + {"E_R", "millivolt", "membrane"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, + {"g_Na", "milliS_per_cm2", "sodium_channel"}, + {"g_K", "milliS_per_cm2", "potassium_channel"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_INFO[] = { + {"i_Stim", "microA_per_cm2", "membrane"}, + {"i_L", "microA_per_cm2", "leakage_current"}, + {"i_K", "microA_per_cm2", "potassium_channel"}, + {"E_L", "millivolt", "leakage_current"}, + {"E_Na", "millivolt", "sodium_channel"}, + {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, + {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, + {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, + {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, + {"E_K", "millivolt", "potassium_channel"}, + {"beta_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +const VariableInfo EXTERNAL_INFO[] = { + {"V", "millivolt", "membrane"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"alpha_n", "per_millisecond", "potassium_channel_n_gate"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicArray() +{ + double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalsArray() +{ + double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraic; + double *externals; +} RootFindingInfo; + +extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), + double *u, size_t n, void *data); + +void objectiveFunction0(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[0] = u[0]; + + f[0] = algebraic[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[0]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + algebraic[0] = u[0]; +} + +void objectiveFunction2(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[3] = u[0]; + + f[0] = algebraic[3]-(constants[1]-10.613)-0.0; +} + +void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[3]; + + nlaSolve(objectiveFunction2, u, 1, &rfi); + + algebraic[3] = u[0]; +} + +void objectiveFunction3(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[1] = u[0]; + + f[0] = algebraic[1]-constants[2]*(externals[0]-algebraic[3])-0.0; +} + +void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[1]; + + nlaSolve(objectiveFunction3, u, 1, &rfi); + + algebraic[1] = u[0]; +} + +void objectiveFunction4(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[4] = u[0]; + + f[0] = algebraic[4]-(constants[1]-115.0)-0.0; +} + +void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[4]; + + nlaSolve(objectiveFunction4, u, 1, &rfi); + + algebraic[4] = u[0]; +} + +void objectiveFunction6(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[5] = u[0]; + + f[0] = algebraic[5]-0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0)-0.0; +} + +void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[5]; + + nlaSolve(objectiveFunction6, u, 1, &rfi); + + algebraic[5] = u[0]; +} + +void objectiveFunction7(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[6] = u[0]; + + f[0] = algebraic[6]-4.0*exp(externals[0]/18.0)-0.0; +} + +void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[6]; + + nlaSolve(objectiveFunction7, u, 1, &rfi); + + algebraic[6] = u[0]; +} + +void objectiveFunction8(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + rates[1] = u[0]; + + f[0] = rates[1]-(algebraic[5]*(1.0-states[1])-algebraic[6]*states[1])-0.0; +} + +void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = rates[1]; + + nlaSolve(objectiveFunction8, u, 1, &rfi); + + rates[1] = u[0]; +} + +void objectiveFunction9(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[7] = u[0]; + + f[0] = algebraic[7]-0.07*exp(externals[0]/20.0)-0.0; +} + +void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[7]; + + nlaSolve(objectiveFunction9, u, 1, &rfi); + + algebraic[7] = u[0]; +} + +void objectiveFunction10(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[8] = u[0]; + + f[0] = algebraic[8]-1.0/(exp((externals[0]+30.0)/10.0)+1.0)-0.0; +} + +void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[8]; + + nlaSolve(objectiveFunction10, u, 1, &rfi); + + algebraic[8] = u[0]; +} + +void objectiveFunction11(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + rates[0] = u[0]; + + f[0] = rates[0]-(algebraic[7]*(1.0-states[0])-algebraic[8]*states[0])-0.0; +} + +void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = rates[0]; + + nlaSolve(objectiveFunction11, u, 1, &rfi); + + rates[0] = u[0]; +} + +void objectiveFunction12(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[9] = u[0]; + + f[0] = algebraic[9]-(constants[1]+12.0)-0.0; +} + +void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[9]; + + nlaSolve(objectiveFunction12, u, 1, &rfi); + + algebraic[9] = u[0]; +} + +void objectiveFunction13(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[2] = u[0]; + + f[0] = algebraic[2]-constants[4]*pow(states[2], 4.0)*(externals[0]-algebraic[9])-0.0; +} + +void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[2]; + + nlaSolve(objectiveFunction13, u, 1, &rfi); + + algebraic[2] = u[0]; +} + +void objectiveFunction15(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[10] = u[0]; + + f[0] = algebraic[10]-0.125*exp(externals[0]/80.0)-0.0; +} + +void findRoot15(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[10]; + + nlaSolve(objectiveFunction15, u, 1, &rfi); + + algebraic[10] = u[0]; +} + +void objectiveFunction16(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + rates[2] = u[0]; + + f[0] = rates[2]-(externals[2]*(1.0-states[2])-algebraic[10]*states[2])-0.0; +} + +void findRoot16(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = rates[2]; + + nlaSolve(objectiveFunction16, u, 1, &rfi); + + rates[2] = u[0]; +} + +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +{ + states[0] = 0.6; + states[1] = 0.05; + states[2] = 0.325; + rates[0] = 0.0; + rates[1] = 0.0; + rates[2] = 0.0; + constants[0] = 1.0; + constants[1] = 0.0; + constants[2] = 0.3; + constants[3] = 120.0; + constants[4] = 36.0; + algebraic[0] = 0.0; + algebraic[1] = 0.0; + algebraic[2] = 0.0; + algebraic[3] = 0.0; + algebraic[4] = 0.0; + algebraic[5] = 0.0; + algebraic[6] = 0.0; + algebraic[7] = 0.0; + algebraic[8] = 0.0; + algebraic[9] = 0.0; + algebraic[10] = 0.0; +} + +void computeComputedConstants(double *constants, double *computedConstants) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +{ + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); + findRoot6(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot7(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot8(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot9(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot10(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot11(voi, states, rates, constants, computedConstants, algebraic, externals); + externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); + findRoot15(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot16(voi, states, rates, constants, computedConstants, algebraic, externals); +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +{ + findRoot0(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot2(voi, states, rates, constants, computedConstants, algebraic, externals); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); + findRoot3(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot4(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot12(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot13(voi, states, rates, constants, computedConstants, algebraic, externals); + externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); +} diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h new file mode 100644 index 000000000..f07a94f94 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h @@ -0,0 +1,42 @@ +/* The content of this file was generated using the C profile of libCellML 0.5.0. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_COUNT; +extern const size_t EXTERNAL_COUNT; + +typedef struct { + char name[8]; + char units[16]; + char component[25]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_INFO[]; +extern const VariableInfo EXTERNAL_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicArray(); +double * createExternalsArray(); + +void deleteArray(double *array); + +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); + +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeComputedConstants(double *constants, double *computedConstants); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py new file mode 100644 index 000000000..2c8ccfc18 --- /dev/null +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py @@ -0,0 +1,478 @@ +# The content of this file was generated using the Python profile of libCellML 0.5.0. + +from enum import Enum +from math import * + + +__version__ = "0.5.0" +LIBCELLML_VERSION = "0.5.0" + +STATE_COUNT = 3 +CONSTANT_COUNT = 5 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_COUNT = 11 +EXTERNAL_COUNT = 3 + +VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} + +STATE_INFO = [ + {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, + {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} +] + +CONSTANT_INFO = [ + {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, + {"name": "E_R", "units": "millivolt", "component": "membrane"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, + {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, + {"name": "g_K", "units": "milliS_per_cm2", "component": "potassium_channel"} +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_INFO = [ + {"name": "i_Stim", "units": "microA_per_cm2", "component": "membrane"}, + {"name": "i_L", "units": "microA_per_cm2", "component": "leakage_current"}, + {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"}, + {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, + {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, + {"name": "E_K", "units": "millivolt", "component": "potassium_channel"}, + {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + +EXTERNAL_INFO = [ + {"name": "V", "units": "millivolt", "component": "membrane"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} +] + + +def leq_func(x, y): + return 1.0 if x <= y else 0.0 + + +def geq_func(x, y): + return 1.0 if x >= y else 0.0 + + +def and_func(x, y): + return 1.0 if bool(x) & bool(y) else 0.0 + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_array(): + return [nan]*ALGEBRAIC_COUNT + + +def create_externals_array(): + return [nan]*EXTERNAL_COUNT + + +from nlasolver import nla_solve + + +def objective_function_0(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + algebraic[0] = u[0] + + f[0] = algebraic[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[0] + + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + algebraic[0] = u[0] + + +def objective_function_2(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + algebraic[3] = u[0] + + f[0] = algebraic[3]-(constants[1]-10.613)-0.0 + + +def find_root_2(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[3] + + u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + algebraic[3] = u[0] + + +def objective_function_3(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + algebraic[1] = u[0] + + f[0] = algebraic[1]-constants[2]*(externals[0]-algebraic[3])-0.0 + + +def find_root_3(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[1] + + u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + algebraic[1] = u[0] + + +def objective_function_4(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + algebraic[4] = u[0] + + f[0] = algebraic[4]-(constants[1]-115.0)-0.0 + + +def find_root_4(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[4] + + u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + algebraic[4] = u[0] + + +def objective_function_6(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + algebraic[5] = u[0] + + f[0] = algebraic[5]-0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0)-0.0 + + +def find_root_6(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[5] + + u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + algebraic[5] = u[0] + + +def objective_function_7(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + algebraic[6] = u[0] + + f[0] = algebraic[6]-4.0*exp(externals[0]/18.0)-0.0 + + +def find_root_7(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[6] + + u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + algebraic[6] = u[0] + + +def objective_function_8(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + rates[1] = u[0] + + f[0] = rates[1]-(algebraic[5]*(1.0-states[1])-algebraic[6]*states[1])-0.0 + + +def find_root_8(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = rates[1] + + u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + rates[1] = u[0] + + +def objective_function_9(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + algebraic[7] = u[0] + + f[0] = algebraic[7]-0.07*exp(externals[0]/20.0)-0.0 + + +def find_root_9(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[7] + + u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + algebraic[7] = u[0] + + +def objective_function_10(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + algebraic[8] = u[0] + + f[0] = algebraic[8]-1.0/(exp((externals[0]+30.0)/10.0)+1.0)-0.0 + + +def find_root_10(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[8] + + u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + algebraic[8] = u[0] + + +def objective_function_11(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + rates[0] = u[0] + + f[0] = rates[0]-(algebraic[7]*(1.0-states[0])-algebraic[8]*states[0])-0.0 + + +def find_root_11(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = rates[0] + + u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + rates[0] = u[0] + + +def objective_function_12(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + algebraic[9] = u[0] + + f[0] = algebraic[9]-(constants[1]+12.0)-0.0 + + +def find_root_12(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[9] + + u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + algebraic[9] = u[0] + + +def objective_function_13(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + algebraic[2] = u[0] + + f[0] = algebraic[2]-constants[4]*pow(states[2], 4.0)*(externals[0]-algebraic[9])-0.0 + + +def find_root_13(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[2] + + u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + algebraic[2] = u[0] + + +def objective_function_15(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + algebraic[10] = u[0] + + f[0] = algebraic[10]-0.125*exp(externals[0]/80.0)-0.0 + + +def find_root_15(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[10] + + u = nla_solve(objective_function_15, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + algebraic[10] = u[0] + + +def objective_function_16(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic = data[5] + externals = data[6] + + rates[2] = u[0] + + f[0] = rates[2]-(externals[2]*(1.0-states[2])-algebraic[10]*states[2])-0.0 + + +def find_root_16(voi, states, rates, constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = rates[2] + + u = nla_solve(objective_function_16, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + + rates[2] = u[0] + + +def initialise_variables(states, rates, constants, computed_constants, algebraic): + states[0] = 0.6 + states[1] = 0.05 + states[2] = 0.325 + rates[0] = 0.0 + rates[1] = 0.0 + rates[2] = 0.0 + constants[0] = 1.0 + constants[1] = 0.0 + constants[2] = 0.3 + constants[3] = 120.0 + constants[4] = 36.0 + algebraic[0] = 0.0 + algebraic[1] = 0.0 + algebraic[2] = 0.0 + algebraic[3] = 0.0 + algebraic[4] = 0.0 + algebraic[5] = 0.0 + algebraic[6] = 0.0 + algebraic[7] = 0.0 + algebraic[8] = 0.0 + algebraic[9] = 0.0 + algebraic[10] = 0.0 + + +def compute_computed_constants(constants, computed_constants): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) + find_root_6(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_7(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_8(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_9(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_10(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_11(voi, states, rates, constants, computed_constants, algebraic, externals) + externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) + find_root_15(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_16(voi, states, rates, constants, computed_constants, algebraic, externals) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): + find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_2(voi, states, rates, constants, computed_constants, algebraic, externals) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) + find_root_3(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_4(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_12(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_13(voi, states, rates, constants, computed_constants, algebraic, externals) + externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) From 49b3a4fdde1dd478b9f1c266e5322850bcaba28e Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 6 Sep 2024 13:24:12 +1200 Subject: [PATCH 54/74] Tests: changed the external variable in algebraicEqnWithOneNonIsolatedUnknownWithExternalVariable. This is so that we can test an algebraic model with an external variable (in https://github.com/agarny/libCellMLGeneratedCodeTests). --- tests/generator/generator.cpp | 2 +- .../model.external.c | 47 ++++++++++++++++--- .../model.external.py | 37 ++++++++++++--- 3 files changed, 73 insertions(+), 13 deletions(-) diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index bfb2d35c8..d84acefb8 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -335,7 +335,7 @@ TEST(Generator, algebraicEqnWithOneNonIsolatedUnknownWithExternalVariable) auto analyser = libcellml::Analyser::create(); - analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(model->component("my_algebraic_eqn")->variable("a"))); + analyser->addExternalVariable(libcellml::AnalyserExternalVariable::create(model->component("my_algebraic_eqn")->variable("c"))); analyser->analyseModel(model); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index a1a60e49f..e14101cab 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -9,8 +9,8 @@ const char VERSION[] = "0.6.0"; const char LIBCELLML_VERSION[] = "0.5.0"; const size_t CONSTANT_COUNT = 0; -const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 2; +const size_t ALGEBRAIC_COUNT = 1; const size_t EXTERNAL_COUNT = 1; const VariableInfo CONSTANT_INFO[] = { @@ -18,15 +18,15 @@ const VariableInfo CONSTANT_INFO[] = { const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"b", "dimensionless", "my_algebraic_eqn"}, - {"c", "dimensionless", "my_algebraic_eqn"}, {"d", "dimensionless", "my_algebraic_eqn"} }; const VariableInfo ALGEBRAIC_INFO[] = { + {"a", "dimensionless", "my_algebraic_eqn"} }; const VariableInfo EXTERNAL_INFO[] = { - {"a", "dimensionless", "my_algebraic_eqn"} + {"c", "dimensionless", "my_algebraic_eqn"} }; double * createConstantsArray() @@ -78,11 +78,45 @@ void deleteArray(double *array) free(array); } +typedef struct { + double *constants; + double *computedConstants; + double *algebraic; + double *externals; +} RootFindingInfo; + +extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), + double *u, size_t n, void *data); + +void objectiveFunction0(double *u, double *f, void *data) +{ + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *externals = ((RootFindingInfo *) data)->externals; + + algebraic[0] = u[0]; + + f[0] = algebraic[0]+computedConstants[0]-(externals[0]+computedConstants[1]); +} + +void findRoot0(double *constants, double *computedConstants, double *algebraic, double *externals) +{ + RootFindingInfo rfi = { constants, computedConstants, algebraic, externals }; + double u[1]; + + u[0] = algebraic[0]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + algebraic[0] = u[0]; +} + void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = 3.0; - computedConstants[1] = 5.0; - computedConstants[2] = 7.0; + computedConstants[1] = 7.0; + algebraic[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -92,4 +126,5 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); + findRoot0(constants, computedConstants, algebraic, externals); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 927ddba3f..327ffac69 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -8,8 +8,8 @@ LIBCELLML_VERSION = "0.5.0" CONSTANT_COUNT = 0 -COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 2 +ALGEBRAIC_COUNT = 1 EXTERNAL_COUNT = 1 CONSTANT_INFO = [ @@ -17,15 +17,15 @@ COMPUTED_CONSTANT_INFO = [ {"name": "b", "units": "dimensionless", "component": "my_algebraic_eqn"}, - {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn"}, {"name": "d", "units": "dimensionless", "component": "my_algebraic_eqn"} ] ALGEBRAIC_INFO = [ + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} ] EXTERNAL_INFO = [ - {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} + {"name": "c", "units": "dimensionless", "component": "my_algebraic_eqn"} ] @@ -45,10 +45,34 @@ def create_externals_array(): return [nan]*EXTERNAL_COUNT +from nlasolver import nla_solve + + +def objective_function_0(u, f, data): + constants = data[0] + computed_constants = data[1] + algebraic = data[2] + externals = data[3] + + algebraic[0] = u[0] + + f[0] = algebraic[0]+computed_constants[0]-(externals[0]+computed_constants[1]) + + +def find_root_0(constants, computed_constants, algebraic, externals): + u = [nan]*1 + + u[0] = algebraic[0] + + u = nla_solve(objective_function_0, u, 1, [constants, computed_constants, algebraic, externals]) + + algebraic[0] = u[0] + + def initialise_variables(constants, computed_constants, algebraic): computed_constants[0] = 3.0 - computed_constants[1] = 5.0 - computed_constants[2] = 7.0 + computed_constants[1] = 7.0 + algebraic[0] = 1.0 def compute_computed_constants(constants, computed_constants): @@ -57,3 +81,4 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, externals, external_variable): externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) + find_root_0(constants, computed_constants, algebraic, externals) From 6b74014367366addec366bddaf2e8ce8a96c8db4 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 10 Sep 2024 15:16:54 +1200 Subject: [PATCH 55/74] Python: improved the API documentation. --- src/bindings/interface/generatorprofile.i | 54 +++++++++++------------ 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/src/bindings/interface/generatorprofile.i b/src/bindings/interface/generatorprofile.i index 426cd08a2..62cb5f26d 100644 --- a/src/bindings/interface/generatorprofile.i +++ b/src/bindings/interface/generatorprofile.i @@ -611,15 +611,15 @@ "Returns the string for a comment."; %feature("docstring") libcellml::GeneratorProfile::setCommentString -"Sets the string for a comment. To be useful, the string should contain the tag, which will be replaced +"Sets the string for a comment. To be useful, the string should contain the [CODE] tag, which will be replaced with a (proper) comment."; %feature("docstring") libcellml::GeneratorProfile::originCommentString "Returns the string for an origin comment."; %feature("docstring") libcellml::GeneratorProfile::setOriginCommentString -"Sets the string for an origin comment. To be useful, the string should contain the and - tags, which will be replaced with a statement about the profile and the version of libCellML +"Sets the string for an origin comment. To be useful, the string should contain the [PROFILE_INFORMATION] and +[LIBCELLML_VERSION] tags, which will be replaced with a statement about the profile and the version of libCellML used respectively."; %feature("docstring") libcellml::GeneratorProfile::interfaceFileNameString @@ -675,7 +675,7 @@ used respectively."; %feature("docstring") libcellml::GeneratorProfile::setImplementationStateCountString "Sets the string for the implementation of the state count constant. To be useful, the string should contain the - tag, which will be replaced with the number of states in the model."; +[STATE_COUNT] tag, which will be replaced with the number of states in the model."; %feature("docstring") libcellml::GeneratorProfile::interfaceConstantCountString "Returns the string for the interface of the constant count constant."; @@ -688,7 +688,7 @@ used respectively."; %feature("docstring") libcellml::GeneratorProfile::setImplementationConstantCountString "Sets the string for the implementation of the constant count constant. To be useful, the string should contain -the tag, which will be replaced with the number of states in the model."; +the [CONSTANT_COUNT] tag, which will be replaced with the number of states in the model."; %feature("docstring") libcellml::GeneratorProfile::interfaceComputedConstantCountString "Returns the string for the interface of the computed constant count constant."; @@ -701,7 +701,7 @@ the tag, which will be replaced with the number of states in th %feature("docstring") libcellml::GeneratorProfile::setImplementationComputedConstantCountString "Sets the string for the implementation of the computed constant count constant. To be useful, the string should contain -the tag, which will be replaced with the number of states in the model."; +the [COMPUTED_CONSTANT_COUNT] tag, which will be replaced with the number of states in the model."; %feature("docstring") libcellml::GeneratorProfile::interfaceAlgebraicCountString "Returns the string for the interface of the algebraic count constant."; @@ -714,7 +714,7 @@ the tag, which will be replaced with the number of sta %feature("docstring") libcellml::GeneratorProfile::setImplementationAlgebraicCountString "Sets the string for the implementation of the algebraic count constant. To be useful, the string should contain -the tag, which will be replaced with the number of states in the model."; +the [ALGEBRAIC_COUNT] tag, which will be replaced with the number of states in the model."; %feature("docstring") libcellml::GeneratorProfile::interfaceExternalCountString "Returns the string for the interface of the external count constant."; @@ -727,14 +727,14 @@ the tag, which will be replaced with the number of states in t %feature("docstring") libcellml::GeneratorProfile::setImplementationExternalCountString "Sets the string for the implementation of the external count constant. To be useful, the string should contain -the tag, which will be replaced with the number of states in the model."; +the [EXTERNAL_COUNT] tag, which will be replaced with the number of states in the model."; %feature("docstring") libcellml::GeneratorProfile::variableInfoObjectString "Returns the string for the data structure for the variable information object."; %feature("docstring") libcellml::GeneratorProfile::setVariableInfoObjectString "Sets the string for the data structure for the variable information object. To be useful, the string should -contain the , and tags, which will be replaced with the maximum size of +contain the [NAME_SIZE], [UNITS_SIZE] and [COMPONENT_SIZE] tags, which will be replaced with the maximum size of a string for holding the name of a component, variable and units, respectively."; %feature("docstring") libcellml::GeneratorProfile::interfaceVoiInfoString @@ -748,7 +748,7 @@ a string for holding the name of a component, variable and units, respectively." %feature("docstring") libcellml::GeneratorProfile::setImplementationVoiInfoString "Sets the string for the implementation of some information about the variable of integration. To be useful, the -string should contain the tag, which will be replaced with some information about the variable of +string should contain the [CODE] tag, which will be replaced with some information about the variable of integration."; %feature("docstring") libcellml::GeneratorProfile::interfaceStateInfoString @@ -762,7 +762,7 @@ integration."; %feature("docstring") libcellml::GeneratorProfile::setImplementationStateInfoString "Sets the string for the implementation of some information about the different states. To be useful, the string -should contain the tag, which will be replaced with some information about the different states."; +should contain the [CODE] tag, which will be replaced with some information about the different states."; %feature("docstring") libcellml::GeneratorProfile::interfaceConstantInfoString "Returns the string for the interface of some information about the different constants."; @@ -775,7 +775,7 @@ should contain the tag, which will be replaced with some information abou %feature("docstring") libcellml::GeneratorProfile::setImplementationConstantInfoString "Sets the string for the implementation of some information about the different constants. To be useful, the string -should contain the tag, which will be replaced with some information about the different constants."; +should contain the [CODE] tag, which will be replaced with some information about the different constants."; %feature("docstring") libcellml::GeneratorProfile::interfaceComputedConstantInfoString "Returns the string for the interface of some information about the different computed constants."; @@ -788,7 +788,7 @@ should contain the tag, which will be replaced with some information abou %feature("docstring") libcellml::GeneratorProfile::setImplementationComputedConstantInfoString "Sets the string for the implementation of some information about the different computed constants. To be useful, the string -should contain the tag, which will be replaced with some information about the different computed constants."; +should contain the [CODE] tag, which will be replaced with some information about the different computed constants."; %feature("docstring") libcellml::GeneratorProfile::interfaceAlgebraicInfoString "Returns the string for the interface of some information about the different algebraic variables."; @@ -801,7 +801,7 @@ should contain the tag, which will be replaced with some information abou %feature("docstring") libcellml::GeneratorProfile::setImplementationAlgebraicInfoString "Sets the string for the implementation of some information about the different algebraic variables. To be useful, the string -should contain the tag, which will be replaced with some information about the different algebraic variables."; +should contain the [CODE] tag, which will be replaced with some information about the different algebraic variables."; %feature("docstring") libcellml::GeneratorProfile::interfaceExternalInfoString "Returns the string for the interface of some information about the different external variables."; @@ -814,14 +814,14 @@ should contain the tag, which will be replaced with some information abou %feature("docstring") libcellml::GeneratorProfile::setImplementationExternalInfoString "Sets the string for the implementation of some information about the different external variables. To be useful, the string -should contain the tag, which will be replaced with some information about the different external variables."; +should contain the [CODE] tag, which will be replaced with some information about the different external variables."; %feature("docstring") libcellml::GeneratorProfile::variableInfoEntryString "Returns the string for an entry in an array for some information about a variable."; %feature("docstring") libcellml::GeneratorProfile::setVariableInfoEntryString "Sets the string for an entry in an array for some information about a variable. To be useful, the string should -contain the , and tags, which will be replaced with the name of the component, name +contain the [COMPONENT], [NAME] and [UNITS] tags, which will be replaced with the name of the component, name and units of a variable respectively."; %feature("docstring") libcellml::GeneratorProfile::voiString @@ -927,14 +927,14 @@ and units of a variable respectively."; "Sets the string for the f array used in the objective function and find root methods."; %feature("docstring") libcellml::GeneratorProfile::setReturnCreatedArrayString -"Sets the string for returning a created array. To be useful, the string should contain the tag, +"Sets the string for returning a created array. To be useful, the string should contain the [ARRAY_SIZE] tag, which will be replaced with the size of the array to be created."; %feature("docstring") libcellml::GeneratorProfile::interfaceCreateStatesArrayMethodString "Returns the string for the interface to create the states array."; %feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateStatesArrayMethodString -"Sets the string for the interface to create the states array. To be useful, the string should contain the +"Sets the string for the interface to create the states array. To be useful, the string should contain the [CODE] tag, which will be replaced with some code to create the states array."; %feature("docstring") libcellml::GeneratorProfile::implementationCreateStatesArrayMethodString @@ -942,13 +942,13 @@ tag, which will be replaced with some code to create the states array."; %feature("docstring") libcellml::GeneratorProfile::setImplementationCreateStatesArrayMethodString "Sets the string for the implementation to create the states array. To be useful, the string should contain the - tag, which will be replaced with some code to create the states array."; +[CODE] tag, which will be replaced with some code to create the states array."; %feature("docstring") libcellml::GeneratorProfile::interfaceCreateConstantsArrayMethodString "Returns the string for the interface to create the constants array."; %feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateConstantsArrayMethodString -"Sets the string for the interface to create the constants array. To be useful, the string should contain the +"Sets the string for the interface to create the constants array. To be useful, the string should contain the [CODE] tag, which will be replaced with some code to create the constants array."; %feature("docstring") libcellml::GeneratorProfile::implementationCreateConstantsArrayMethodString @@ -956,13 +956,13 @@ tag, which will be replaced with some code to create the constants array."; %feature("docstring") libcellml::GeneratorProfile::setImplementationCreateConstantsArrayMethodString "Sets the string for the implementation to create the constants array. To be useful, the string should contain the - tag, which will be replaced with some code to create the constants array."; +[CODE] tag, which will be replaced with some code to create the constants array."; %feature("docstring") libcellml::GeneratorProfile::interfaceCreateComputedConstantsArrayMethodString "Returns the string for the interface to create the computed constants array."; %feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateComputedConstantsArrayMethodString -"Sets the string for the interface to create the computed constants array. To be useful, the string should contain the +"Sets the string for the interface to create the computed constants array. To be useful, the string should contain the [CODE] tag, which will be replaced with some code to create the computed constants array."; %feature("docstring") libcellml::GeneratorProfile::implementationCreateComputedConstantsArrayMethodString @@ -970,13 +970,13 @@ tag, which will be replaced with some code to create the computed constants arra %feature("docstring") libcellml::GeneratorProfile::setImplementationCreateComputedConstantsArrayMethodString "Sets the string for the implementation to create the computed constants array. To be useful, the string should contain the - tag, which will be replaced with some code to create the computed constants array."; +[CODE] tag, which will be replaced with some code to create the computed constants array."; %feature("docstring") libcellml::GeneratorProfile::interfaceCreateAlgebraicArrayMethodString "Returns the string for the interface to create the algebraic array."; %feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateAlgebraicArrayMethodString -"Sets the string for the interface to create the algebraic array. To be useful, the string should contain the +"Sets the string for the interface to create the algebraic array. To be useful, the string should contain the [CODE] tag, which will be replaced with some code to create the algebraic array."; %feature("docstring") libcellml::GeneratorProfile::implementationCreateAlgebraicArrayMethodString @@ -984,13 +984,13 @@ tag, which will be replaced with some code to create the algebraic array."; %feature("docstring") libcellml::GeneratorProfile::setImplementationCreateAlgebraicArrayMethodString "Sets the string for the implementation to create the algebraic array. To be useful, the string should contain the - tag, which will be replaced with some code to create the algebraic array."; +[CODE] tag, which will be replaced with some code to create the algebraic array."; %feature("docstring") libcellml::GeneratorProfile::interfaceCreateExternalsArrayMethodString "Returns the string for the interface to create the externals array."; %feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateExternalsArrayMethodString -"Sets the string for the interface to create the externals array. To be useful, the string should contain the +"Sets the string for the interface to create the externals array. To be useful, the string should contain the [CODE] tag, which will be replaced with some code to create the externals array."; %feature("docstring") libcellml::GeneratorProfile::implementationCreateExternalsArrayMethodString @@ -998,7 +998,7 @@ tag, which will be replaced with some code to create the externals array."; %feature("docstring") libcellml::GeneratorProfile::setImplementationCreateExternalsArrayMethodString "Sets the string for the implementation to create the externals array. To be useful, the string should contain the - tag, which will be replaced with some code to create the externals array."; +[CODE] tag, which will be replaced with some code to create the externals array."; %feature("docstring") libcellml::GeneratorProfile::interfaceDeleteArrayMethodString "Returns the string for the interface to delete an array."; From dcbd03817694897efb75349b77997202c85954e4 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 10 Sep 2024 16:44:23 +1200 Subject: [PATCH 56/74] Some minor cleaning up. --- src/debug.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/debug.cpp b/src/debug.cpp index 8a7b330e6..a41ed57b4 100644 --- a/src/debug.cpp +++ b/src/debug.cpp @@ -194,7 +194,6 @@ void printHistory(const History &history) for (const auto &h : history) { printHistoryEpoch(h); } - } void printHistoryEpoch(const HistoryEpochPtr &historyEpoch) @@ -234,7 +233,8 @@ void printEquivalenceMap(const EquivalenceMap &map) void printEquivalenceMapWithModelInfo(const EquivalenceMap &map, const ModelPtr &model) { for (const auto &iter : map) { - auto key = iter.first; Debug(false) << "key: "; + auto key = iter.first; + Debug(false) << "key: "; printStackWithModelInfo(key, model); auto vector = iter.second; for (const auto &vectorIt : vector) { From 8563e4bbf34b6e330a300011566be02dfcaa230c Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 22 Oct 2024 11:15:09 +1300 Subject: [PATCH 57/74] Some minor cleaning up. --- src/analyser_p.h | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/analyser_p.h b/src/analyser_p.h index f79606e06..97779631a 100644 --- a/src/analyser_p.h +++ b/src/analyser_p.h @@ -257,9 +257,7 @@ class Analyser::AnalyserImpl: public Logger::LoggerImpl void analyseModel(const ModelPtr &model); - AnalyserExternalVariablePtrs::const_iterator findExternalVariable(const ModelPtr &model, - const std::string &componentName, - const std::string &variableName) const; + AnalyserExternalVariablePtrs::const_iterator findExternalVariable(const VariablePtr &variable) const; AnalyserExternalVariablePtrs::const_iterator findExternalVariable(const AnalyserExternalVariablePtr &externalVariable) const; }; From 4c4842f2dae10f4963cc616e94c58d6a0f90a631 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 22 Oct 2024 13:03:29 +1300 Subject: [PATCH 58/74] Some minor cleaning up. --- .../model.external.c | 4 ++-- .../model.external.h | 2 +- .../model.external.py | 4 ++-- .../hodgkin_huxley_squid_axon_model_1952/model.dae.external.c | 4 ++-- .../hodgkin_huxley_squid_axon_model_1952/model.dae.external.h | 2 +- .../model.dae.external.py | 4 ++-- 6 files changed, 10 insertions(+), 10 deletions(-) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c index d58310558..4973adedc 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c @@ -1,4 +1,4 @@ -/* The content of this file was generated using the C profile of libCellML 0.5.0. */ +/* The content of this file was generated using the C profile of libCellML 0.6.0. */ #include "model.external.h" @@ -6,7 +6,7 @@ #include const char VERSION[] = "0.6.0"; -const char LIBCELLML_VERSION[] = "0.5.0"; +const char LIBCELLML_VERSION[] = "0.6.0"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h index eb786b587..cf2092507 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h @@ -1,4 +1,4 @@ -/* The content of this file was generated using the C profile of libCellML 0.5.0. */ +/* The content of this file was generated using the C profile of libCellML 0.6.0. */ #pragma once diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py index e72866bd3..eabc3752c 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py @@ -1,11 +1,11 @@ -# The content of this file was generated using the Python profile of libCellML 0.5.0. +# The content of this file was generated using the Python profile of libCellML 0.6.0. from enum import Enum from math import * __version__ = "0.5.0" -LIBCELLML_VERSION = "0.5.0" +LIBCELLML_VERSION = "0.6.0" CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c index 3d179b3e0..4998481cb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c @@ -1,4 +1,4 @@ -/* The content of this file was generated using the C profile of libCellML 0.5.0. */ +/* The content of this file was generated using the C profile of libCellML 0.6.0. */ #include "model.dae.external.h" @@ -6,7 +6,7 @@ #include const char VERSION[] = "0.6.0"; -const char LIBCELLML_VERSION[] = "0.5.0"; +const char LIBCELLML_VERSION[] = "0.6.0"; const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 5; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h index f07a94f94..a4fb541db 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h @@ -1,4 +1,4 @@ -/* The content of this file was generated using the C profile of libCellML 0.5.0. */ +/* The content of this file was generated using the C profile of libCellML 0.6.0. */ #pragma once diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py index 2c8ccfc18..5ae1b2523 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py @@ -1,11 +1,11 @@ -# The content of this file was generated using the Python profile of libCellML 0.5.0. +# The content of this file was generated using the Python profile of libCellML 0.6.0. from enum import Enum from math import * __version__ = "0.5.0" -LIBCELLML_VERSION = "0.5.0" +LIBCELLML_VERSION = "0.6.0" STATE_COUNT = 3 CONSTANT_COUNT = 5 From d1c8fb50cfe77ad0f209f63560c7328fc80da35e Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 15 Nov 2024 09:44:14 +1300 Subject: [PATCH 59/74] Some minor cleaning up following the last merge. --- .../model.external.c | 4 ++-- .../model.external.h | 2 +- .../model.external.py | 4 ++-- .../hodgkin_huxley_squid_axon_model_1952/model.dae.external.c | 4 ++-- .../hodgkin_huxley_squid_axon_model_1952/model.dae.external.h | 2 +- .../model.dae.external.py | 4 ++-- 6 files changed, 10 insertions(+), 10 deletions(-) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c index 569447809..386a0be1c 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c @@ -1,4 +1,4 @@ -/* The content of this file was generated using the C profile of libCellML 0.6.2. */ +/* The content of this file was generated using the C profile of libCellML 0.6.3. */ #include "model.external.h" @@ -6,7 +6,7 @@ #include const char VERSION[] = "0.6.0"; -const char LIBCELLML_VERSION[] = "0.6.2"; +const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h index 120174f5c..43266515a 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h @@ -1,4 +1,4 @@ -/* The content of this file was generated using the C profile of libCellML 0.6.2. */ +/* The content of this file was generated using the C profile of libCellML 0.6.3. */ #pragma once diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py index 9652ae256..de0df95d2 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py @@ -1,11 +1,11 @@ -# The content of this file was generated using the Python profile of libCellML 0.6.2. +# The content of this file was generated using the Python profile of libCellML 0.6.3. from enum import Enum from math import * __version__ = "0.5.0" -LIBCELLML_VERSION = "0.6.2" +LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c index 3fa8cd50f..bacce2ba8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c @@ -1,4 +1,4 @@ -/* The content of this file was generated using the C profile of libCellML 0.6.2. */ +/* The content of this file was generated using the C profile of libCellML 0.6.3. */ #include "model.dae.external.h" @@ -6,7 +6,7 @@ #include const char VERSION[] = "0.6.0"; -const char LIBCELLML_VERSION[] = "0.6.2"; +const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 5; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h index 2061b2f63..d6171fd1a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h @@ -1,4 +1,4 @@ -/* The content of this file was generated using the C profile of libCellML 0.6.2. */ +/* The content of this file was generated using the C profile of libCellML 0.6.3. */ #pragma once diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py index bfb2728e9..76a61944b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py @@ -1,11 +1,11 @@ -# The content of this file was generated using the Python profile of libCellML 0.6.2. +# The content of this file was generated using the Python profile of libCellML 0.6.3. from enum import Enum from math import * __version__ = "0.5.0" -LIBCELLML_VERSION = "0.6.2" +LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 3 CONSTANT_COUNT = 5 From b26676bea28ebd0bb6b76de0e6361ca21cbb9ac7 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 15 Nov 2024 22:39:00 +1300 Subject: [PATCH 60/74] Fixed macro issue on some Linux systems. --- src/debug.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/debug.cpp b/src/debug.cpp index a41ed57b4..819f79c16 100644 --- a/src/debug.cpp +++ b/src/debug.cpp @@ -29,6 +29,8 @@ limitations under the License. #include "commonutils.h" #include "utilities.h" +#include "libcellml/undefines.h" + namespace libcellml { std::string astAsCode(const AnalyserEquationAstPtr &ast) From 8b590e73bf0e9ec2ec7354c9b46ab657362291bb Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 15 May 2025 11:17:28 +1200 Subject: [PATCH 61/74] Reverted commit 6a48c0fa8. --- src/analyser.cpp | 40 +- tests/analyser/analyser.cpp | 4 +- tests/analyser/analyserunits.cpp | 2 +- tests/resources/coverage/generator/model.c | 400 +++++++-------- .../generator/model.implementation.out | 390 +++++++-------- .../generator/model.modified.profile.c | 400 +++++++-------- .../generator/model.modified.profile.py | 400 +++++++-------- tests/resources/coverage/generator/model.out | 378 +++++++-------- tests/resources/coverage/generator/model.py | 400 +++++++-------- .../algebraic_eqn_computed_var_on_rhs/model.c | 8 +- .../model.py | 8 +- .../model.c | 10 +- .../model.external.c | 4 +- .../model.external.py | 4 +- .../model.py | 10 +- .../model.not.ordered.c | 28 +- .../model.not.ordered.py | 28 +- .../model.ordered.c | 10 +- .../model.ordered.py | 10 +- .../generator/cellml_slc_example/model.py | 30 +- .../generator/dae_cellml_1_1_model/model.c | 20 +- .../generator/dae_cellml_1_1_model/model.py | 20 +- .../generator/dependent_eqns/model.c | 8 +- .../generator/dependent_eqns/model.py | 8 +- .../model.c | 454 +++++++++--------- .../model.py | 454 +++++++++--------- .../model.c | 270 +++++------ .../model.py | 270 +++++------ .../model.algebraic.c | 6 +- .../model.algebraic.py | 6 +- .../model.c | 6 +- .../model.computed.constant.c | 6 +- .../model.computed.constant.py | 6 +- .../model.constant.c | 8 +- .../model.constant.py | 8 +- .../model.dae.c | 12 +- .../model.dae.external.c | 28 +- .../model.dae.external.py | 28 +- .../model.dae.py | 12 +- .../model.dependent.algebraic.c | 4 +- .../model.dependent.algebraic.py | 4 +- .../model.dependent.computed.constant.c | 6 +- .../model.dependent.computed.constant.py | 6 +- .../model.dependent.constant.c | 8 +- .../model.dependent.constant.py | 8 +- .../model.dependent.state.c | 4 +- .../model.dependent.state.py | 4 +- .../model.external.c | 22 +- .../model.external.py | 22 +- .../model.py | 6 +- .../model.state.c | 4 +- .../model.state.py | 4 +- .../generator/noble_model_1962/model.c | 52 +- .../generator/noble_model_1962/model.py | 52 +- .../ode_multiple_dependent_odes/model.c | 12 +- .../ode_multiple_dependent_odes/model.py | 12 +- .../model.c | 12 +- .../model.py | 12 +- .../robertson_model_1966/model.dae.c | 22 +- .../robertson_model_1966/model.dae.py | 22 +- .../robertson_model_1966/model.ode.c | 22 +- .../robertson_model_1966/model.ode.py | 22 +- .../model.c | 28 +- .../model.py | 28 +- 64 files changed, 2295 insertions(+), 2297 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index 518ce6367..64004dd71 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -483,36 +483,34 @@ void Analyser::AnalyserImpl::analyseNode(const XmlNodePtr &node, // +-------------+ auto childCount = mathmlChildCount(node); + AnalyserEquationAstPtr tempAst; + AnalyserEquationAstPtr astRightChild; - analyseNode(mathmlChildNode(node, 0), ast, astParent, component, equation); - - if (childCount >= 2) { - analyseNode(mathmlChildNode(node, 1), ast->mPimpl->mOwnedLeftChild, ast, component, equation); - - if (childCount >= 3) { - AnalyserEquationAstPtr astRightChild; - AnalyserEquationAstPtr tempAst; - - analyseNode(mathmlChildNode(node, childCount - 1), astRightChild, nullptr, component, equation); - - for (auto i = childCount - 2; i > 1; --i) { - tempAst = AnalyserEquationAst::create(); - - analyseNode(mathmlChildNode(node, 0), tempAst, nullptr, component, equation); - analyseNode(mathmlChildNode(node, i), tempAst->mPimpl->mOwnedLeftChild, tempAst, component, equation); + for (size_t i = childCount - 1; i > 0; --i) { + astRightChild = tempAst; + tempAst = AnalyserEquationAst::create(); + if (astRightChild != nullptr) { + if (i == childCount - 2) { + astRightChild->swapLeftAndRightChildren(); + tempAst = astRightChild; + } else { astRightChild->mPimpl->mParent = tempAst; - tempAst->mPimpl->mOwnedRightChild = astRightChild; - astRightChild = tempAst; } + } - astRightChild->mPimpl->mParent = ast; - - ast->mPimpl->mOwnedRightChild = astRightChild; + if (i != childCount - 2) { + analyseNode(mathmlChildNode(node, 0), tempAst, nullptr, component, equation); } + + analyseNode(mathmlChildNode(node, i), tempAst->mPimpl->mOwnedLeftChild, tempAst, component, equation); } + analyseNode(mathmlChildNode(node, 0), tempAst, astParent, component, equation); + + ast = tempAst; + // Relational and logical operators. } else if (node->isMathmlElement("eq")) { diff --git a/tests/analyser/analyser.cpp b/tests/analyser/analyser.cpp index 59c657095..c3f5c8b5a 100644 --- a/tests/analyser/analyser.cpp +++ b/tests/analyser/analyser.cpp @@ -921,8 +921,8 @@ TEST(Analyser, algebraicSystemWithThreeLinkedUnknownsWithOneExternalVariable) EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "Variable 'y' in component 'my_algebraic_system' is computed more than once.", "Variable 'z' in component 'my_algebraic_system' is computed more than once.", + "Variable 'y' in component 'my_algebraic_system' is computed more than once.", }; auto analyser = libcellml::Analyser::create(); @@ -977,8 +977,8 @@ TEST(Analyser, overconstrainedNlaSystem) EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "Variable 'x' in component 'my_algebraic_system' is computed more than once.", "Variable 'y' in component 'my_algebraic_system' is computed more than once.", + "Variable 'x' in component 'my_algebraic_system' is computed more than once.", }; auto analyser = libcellml::Analyser::create(); diff --git a/tests/analyser/analyserunits.cpp b/tests/analyser/analyserunits.cpp index cfa856d8d..0c8cc48b9 100644 --- a/tests/analyser/analyserunits.cpp +++ b/tests/analyser/analyserunits.cpp @@ -883,8 +883,8 @@ TEST(AnalyserUnits, powerValues) "The units in 'eqnPi = pow(x, pi)' in component 'my_component' are not equivalent. 'eqnPi' is in 'second' while 'pow(x, pi)' is in 'second^3.14159'.", "The units in 'eqnInfinity = pow(x, infinity)' in component 'my_component' are not equivalent. 'eqnInfinity' is in 'second' while 'pow(x, infinity)' is in 'second^inf' (i.e. '10^nan x second^inf').", "The units in 'eqnNotanumber = pow(x, notanumber)' in component 'my_component' are not equivalent. 'eqnNotanumber' is in 'second' while 'pow(x, notanumber)' is in 'second^nan' (i.e. '10^nan x second^nan').", - "The type of variable 'eqnCoverage' in component 'my_component' is unknown.", "The type of variable 'u' in component 'my_component' is unknown.", + "The type of variable 'eqnCoverage' in component 'my_component' is unknown.", "The type of variable 'eqnCoverage2' in component 'my_component' is unknown.", "The type of variable 'eqnCoverage3' in component 'my_component' is unknown.", }; diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 49d0304f9..d11b9b73f 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -21,8 +21,8 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo CONSTANT_INFO[] = { - {"m", "dimensionless", "my_component"}, {"n", "dimensionless", "my_component"}, + {"m", "dimensionless", "my_component"}, {"o", "dimensionless", "my_component"}, {"p", "dimensionless", "my_component"}, {"q", "dimensionless", "my_component"}, @@ -228,13 +228,13 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"eqnCoverageForPowerOperator", "dimensionless", "my_component"}, {"eqnCoverageForRootOperator", "dimensionless", "my_component"}, {"eqnCoverageForMinusUnary", "dimensionless", "my_component"}, - {"eqnComputedConstant1", "dimensionless", "my_component"}, - {"eqnComputedConstant2", "dimensionless", "my_component"} + {"eqnComputedConstant2", "dimensionless", "my_component"}, + {"eqnComputedConstant1", "dimensionless", "my_component"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"eqnNlaVariable1", "dimensionless", "my_component"}, - {"eqnNlaVariable2", "dimensionless", "my_component"} + {"eqnNlaVariable2", "dimensionless", "my_component"}, + {"eqnNlaVariable1", "dimensionless", "my_component"} }; const VariableInfo EXTERNAL_INFO[] = { @@ -408,8 +408,8 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[0] = u[0]; algebraic[1] = u[1]; - f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; - f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); + f[0] = algebraic[1]+algebraic[0]+states[0]-0.0; + f[1] = algebraic[1]-algebraic[0]-(computedConstants[198]+computedConstants[197]); } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) @@ -429,8 +429,8 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; - constants[0] = 1.0; - constants[1] = 2.0; + constants[0] = 2.0; + constants[1] = 1.0; constants[2] = 3.0; constants[3] = 4.0; constants[4] = 5.0; @@ -446,201 +446,201 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[184] = 3.14159265358979; computedConstants[185] = INFINITY; computedConstants[186] = NAN; - computedConstants[197] = 1.0; - computedConstants[198] = 3.0; - algebraic[0] = 1.0; - algebraic[1] = 2.0; + computedConstants[198] = 1.0; + computedConstants[197] = 3.0; + algebraic[0] = 2.0; + algebraic[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = constants[0] == constants[1]; - computedConstants[1] = constants[0]/(constants[1] == constants[1]); - computedConstants[2] = constants[0] != constants[1]; - computedConstants[3] = constants[0]/(constants[1] != constants[2]); - computedConstants[4] = constants[0] < constants[1]; - computedConstants[5] = constants[0]/(constants[1] < constants[2]); - computedConstants[6] = constants[0] <= constants[1]; - computedConstants[7] = constants[0]/(constants[1] <= constants[2]); - computedConstants[8] = constants[0] > constants[1]; - computedConstants[9] = constants[0]/(constants[1] > constants[2]); - computedConstants[10] = constants[0] >= constants[1]; - computedConstants[11] = constants[0]/(constants[1] >= constants[2]); - computedConstants[12] = constants[0] && constants[1]; - computedConstants[13] = constants[0] && constants[1] && constants[2]; - computedConstants[14] = (constants[0] < constants[1]) && (constants[2] > constants[3]); - computedConstants[15] = (constants[0]+constants[1]) && (constants[2] > constants[3]); - computedConstants[16] = constants[0] && (constants[1] > constants[2]); - computedConstants[17] = (constants[0]-constants[1]) && (constants[2] > constants[3]); - computedConstants[18] = -constants[0] && (constants[1] > constants[2]); - computedConstants[19] = pow(constants[0], constants[1]) && (constants[2] > constants[3]); - computedConstants[20] = pow(constants[0], 1.0/constants[1]) && (constants[2] > constants[3]); - computedConstants[21] = (constants[0] < constants[1]) && (constants[2]+constants[3]); - computedConstants[22] = (constants[0] < constants[1]) && constants[2]; - computedConstants[23] = (constants[0] < constants[1]) && (constants[2]-constants[3]); - computedConstants[24] = (constants[0] < constants[1]) && -constants[2]; - computedConstants[25] = (constants[0] < constants[1]) && pow(constants[2], constants[3]); - computedConstants[26] = (constants[0] < constants[1]) && pow(constants[2], 1.0/constants[3]); - computedConstants[27] = constants[0]/(constants[1] && constants[2]); - computedConstants[28] = constants[0] || constants[1]; - computedConstants[29] = constants[0] || constants[1] || constants[2]; - computedConstants[30] = (constants[0] < constants[1]) || (constants[2] > constants[3]); - computedConstants[31] = (constants[0]+constants[1]) || (constants[2] > constants[3]); - computedConstants[32] = constants[0] || (constants[1] > constants[2]); - computedConstants[33] = (constants[0]-constants[1]) || (constants[2] > constants[3]); - computedConstants[34] = -constants[0] || (constants[1] > constants[2]); - computedConstants[35] = pow(constants[0], constants[1]) || (constants[2] > constants[3]); - computedConstants[36] = pow(constants[0], 1.0/constants[1]) || (constants[2] > constants[3]); - computedConstants[37] = (constants[0] < constants[1]) || (constants[2]+constants[3]); - computedConstants[38] = (constants[0] < constants[1]) || constants[2]; - computedConstants[39] = (constants[0] < constants[1]) || (constants[2]-constants[3]); - computedConstants[40] = (constants[0] < constants[1]) || -constants[2]; - computedConstants[41] = (constants[0] < constants[1]) || pow(constants[2], constants[3]); - computedConstants[42] = (constants[0] < constants[1]) || pow(constants[2], 1.0/constants[3]); - computedConstants[43] = constants[0]/(constants[1] || constants[2]); - computedConstants[44] = xor(constants[0], constants[1]); - computedConstants[45] = xor(constants[0], xor(constants[1], constants[2])); - computedConstants[46] = xor(constants[0] < constants[1], constants[2] > constants[3]); - computedConstants[47] = xor(constants[0]+constants[1], constants[2] > constants[3]); - computedConstants[48] = xor(constants[0], constants[1] > constants[2]); - computedConstants[49] = xor(constants[0]-constants[1], constants[2] > constants[3]); - computedConstants[50] = xor(-constants[0], constants[1] > constants[2]); - computedConstants[51] = xor(pow(constants[0], constants[1]), constants[2] > constants[3]); - computedConstants[52] = xor(pow(constants[0], 1.0/constants[1]), constants[2] > constants[3]); - computedConstants[53] = xor(constants[0] < constants[1], constants[2]+constants[3]); - computedConstants[54] = xor(constants[0] < constants[1], constants[2]); - computedConstants[55] = xor(constants[0] < constants[1], constants[2]-constants[3]); - computedConstants[56] = xor(constants[0] < constants[1], -constants[2]); - computedConstants[57] = xor(constants[0] < constants[1], pow(constants[2], constants[3])); - computedConstants[58] = xor(constants[0] < constants[1], pow(constants[2], 1.0/constants[3])); - computedConstants[59] = constants[0]/xor(constants[1], constants[2]); - computedConstants[60] = !constants[0]; - computedConstants[61] = constants[0]+constants[1]+constants[2]; - computedConstants[62] = (constants[0] < constants[1])+(constants[2] > constants[3]); - computedConstants[63] = constants[0]; - computedConstants[64] = constants[0]-constants[1]; - computedConstants[65] = (constants[0] < constants[1])-(constants[2] > constants[3]); - computedConstants[66] = (constants[0] < constants[1])-(constants[2]+constants[3]); - computedConstants[67] = (constants[0] < constants[1])-constants[2]; - computedConstants[68] = constants[0]-(-constants[1]); - computedConstants[69] = constants[0]-(-constants[1]*constants[2]); - computedConstants[70] = -constants[0]; - computedConstants[71] = -(constants[0] < constants[1]); - computedConstants[72] = constants[0]*constants[1]; - computedConstants[73] = constants[0]*constants[1]*constants[2]; - computedConstants[74] = (constants[0] < constants[1])*(constants[2] > constants[3]); - computedConstants[75] = (constants[0]+constants[1])*(constants[2] > constants[3]); - computedConstants[76] = constants[0]*(constants[1] > constants[2]); - computedConstants[77] = (constants[0]-constants[1])*(constants[2] > constants[3]); - computedConstants[78] = -constants[0]*(constants[1] > constants[2]); - computedConstants[79] = (constants[0] < constants[1])*(constants[2]+constants[3]); - computedConstants[80] = (constants[0] < constants[1])*constants[2]; - computedConstants[81] = (constants[0] < constants[1])*(constants[2]-constants[3]); - computedConstants[82] = (constants[0] < constants[1])*-constants[2]; - computedConstants[83] = constants[0]/constants[1]; - computedConstants[84] = (constants[0] < constants[1])/(constants[3] > constants[2]); - computedConstants[85] = (constants[0]+constants[1])/(constants[3] > constants[2]); - computedConstants[86] = constants[0]/(constants[2] > constants[1]); - computedConstants[87] = (constants[0]-constants[1])/(constants[3] > constants[2]); - computedConstants[88] = -constants[0]/(constants[2] > constants[1]); - computedConstants[89] = (constants[0] < constants[1])/(constants[2]+constants[3]); - computedConstants[90] = (constants[0] < constants[1])/constants[2]; - computedConstants[91] = (constants[0] < constants[1])/(constants[2]-constants[3]); - computedConstants[92] = (constants[0] < constants[1])/-constants[2]; - computedConstants[93] = (constants[0] < constants[1])/(constants[2]*constants[3]); - computedConstants[94] = (constants[0] < constants[1])/(constants[2]/constants[3]); - computedConstants[95] = sqrt(constants[0]); - computedConstants[96] = pow(constants[0], 2.0); - computedConstants[97] = pow(constants[0], 3.0); - computedConstants[98] = pow(constants[0], constants[1]); - computedConstants[99] = pow(constants[0] <= constants[1], constants[2] >= constants[3]); - computedConstants[100] = pow(constants[0]+constants[1], constants[2] >= constants[3]); - computedConstants[101] = pow(constants[0], constants[1] >= constants[2]); - computedConstants[102] = pow(constants[0]-constants[1], constants[2] >= constants[3]); - computedConstants[103] = pow(-constants[0], constants[1] >= constants[2]); - computedConstants[104] = pow(constants[0]*constants[1], constants[2] >= constants[3]); - computedConstants[105] = pow(constants[0]/constants[1], constants[2] >= constants[3]); - computedConstants[106] = pow(constants[0] <= constants[1], constants[2]+constants[3]); - computedConstants[107] = pow(constants[0] <= constants[1], constants[2]); - computedConstants[108] = pow(constants[0] <= constants[1], constants[2]-constants[3]); - computedConstants[109] = pow(constants[0] <= constants[1], -constants[2]); - computedConstants[110] = pow(constants[0] <= constants[1], constants[2]*constants[3]); - computedConstants[111] = pow(constants[0] <= constants[1], constants[2]/constants[3]); - computedConstants[112] = pow(constants[0] <= constants[1], pow(constants[2], constants[3])); - computedConstants[113] = pow(constants[0] <= constants[1], pow(constants[2], 1.0/constants[3])); - computedConstants[114] = sqrt(constants[0]); - computedConstants[115] = sqrt(constants[0]); - computedConstants[116] = pow(constants[0], 1.0/3.0); - computedConstants[117] = pow(constants[0], 1.0/constants[1]); - computedConstants[118] = pow(constants[0] < constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[119] = pow(constants[0]+constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[120] = pow(constants[0], 1.0/(constants[2] > constants[1])); - computedConstants[121] = pow(constants[0]-constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[122] = pow(-constants[0], 1.0/(constants[2] > constants[1])); - computedConstants[123] = pow(constants[0]*constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[124] = pow(constants[0]/constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[125] = pow(constants[0] < constants[1], 1.0/(constants[2]+constants[3])); - computedConstants[126] = pow(constants[0] < constants[1], 1.0/constants[2]); - computedConstants[127] = pow(constants[0] < constants[1], 1.0/(constants[2]-constants[3])); - computedConstants[128] = pow(constants[0] < constants[1], 1.0/-constants[2]); - computedConstants[129] = pow(constants[0] < constants[1], 1.0/(constants[2]*constants[3])); - computedConstants[130] = pow(constants[0] < constants[1], 1.0/(constants[2]/constants[3])); - computedConstants[131] = pow(constants[0] < constants[1], 1.0/pow(constants[2], constants[3])); - computedConstants[132] = pow(constants[0] < constants[1], 1.0/pow(constants[2], 1.0/constants[3])); - computedConstants[133] = fabs(constants[0]); - computedConstants[134] = exp(constants[0]); - computedConstants[135] = log(constants[0]); - computedConstants[136] = log10(constants[0]); - computedConstants[137] = log(constants[0])/log(2.0); - computedConstants[138] = log10(constants[0]); - computedConstants[139] = log(constants[0])/log(constants[1]); - computedConstants[140] = ceil(constants[0]); - computedConstants[141] = floor(constants[0]); - computedConstants[142] = min(constants[0], constants[1]); - computedConstants[143] = min(constants[0], min(constants[1], constants[2])); - computedConstants[144] = max(constants[0], constants[1]); - computedConstants[145] = max(constants[0], max(constants[1], constants[2])); - computedConstants[146] = fmod(constants[0], constants[1]); - computedConstants[147] = sin(constants[0]); - computedConstants[148] = cos(constants[0]); - computedConstants[149] = tan(constants[0]); - computedConstants[150] = sec(constants[0]); - computedConstants[151] = csc(constants[0]); - computedConstants[152] = cot(constants[0]); - computedConstants[153] = sinh(constants[0]); - computedConstants[154] = cosh(constants[0]); - computedConstants[155] = tanh(constants[0]); - computedConstants[156] = sech(constants[0]); - computedConstants[157] = csch(constants[0]); - computedConstants[158] = coth(constants[0]); - computedConstants[159] = asin(constants[0]); - computedConstants[160] = acos(constants[0]); - computedConstants[161] = atan(constants[0]); - computedConstants[162] = asec(constants[0]); - computedConstants[163] = acsc(constants[0]); - computedConstants[164] = acot(constants[0]); - computedConstants[165] = asinh(constants[0]); - computedConstants[166] = acosh(constants[0]); - computedConstants[167] = atanh(constants[0]/2.0); - computedConstants[168] = asech(constants[0]); - computedConstants[169] = acsch(constants[0]); - computedConstants[170] = acoth(2.0*constants[0]); - computedConstants[171] = (constants[0] > constants[1])?constants[0]:NAN; - computedConstants[172] = (constants[0] > constants[1])?constants[0]:constants[2]; - computedConstants[173] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; - computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; - computedConstants[175] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); - computedConstants[180] = constants[0]; - computedConstants[187] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); - computedConstants[188] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); - computedConstants[189] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); - computedConstants[190] = (constants[0] && constants[1])/(((constants[2] > constants[3])?constants[1]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[1]:NAN))); - computedConstants[191] = (constants[0] || constants[1]) && xor(constants[0], constants[1]) && ((constants[2] > constants[3])?constants[1]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[1]:NAN) && xor(constants[0], constants[1]) && (constants[0] || constants[1]); - computedConstants[192] = (constants[0] && constants[1]) || xor(constants[0], constants[1]) || ((constants[2] > constants[3])?constants[1]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[1]:NAN) || xor(constants[0], constants[1]) || (constants[0] && constants[1]); - computedConstants[193] = xor(constants[0] && constants[1], xor(constants[0] || constants[1], xor((constants[2] > constants[3])?constants[1]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] || constants[1]), constants[0] && constants[1])))); - computedConstants[194] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); - computedConstants[195] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); - computedConstants[196] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); + computedConstants[0] = constants[1] == constants[0]; + computedConstants[1] = constants[1]/(constants[0] == constants[0]); + computedConstants[2] = constants[1] != constants[0]; + computedConstants[3] = constants[1]/(constants[0] != constants[2]); + computedConstants[4] = constants[1] < constants[0]; + computedConstants[5] = constants[1]/(constants[0] < constants[2]); + computedConstants[6] = constants[1] <= constants[0]; + computedConstants[7] = constants[1]/(constants[0] <= constants[2]); + computedConstants[8] = constants[1] > constants[0]; + computedConstants[9] = constants[1]/(constants[0] > constants[2]); + computedConstants[10] = constants[1] >= constants[0]; + computedConstants[11] = constants[1]/(constants[0] >= constants[2]); + computedConstants[12] = constants[1] && constants[0]; + computedConstants[13] = constants[1] && constants[0] && constants[2]; + computedConstants[14] = (constants[1] < constants[0]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[1]+constants[0]) && (constants[2] > constants[3]); + computedConstants[16] = constants[1] && (constants[0] > constants[2]); + computedConstants[17] = (constants[1]-constants[0]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[1] && (constants[0] > constants[2]); + computedConstants[19] = pow(constants[1], constants[0]) && (constants[2] > constants[3]); + computedConstants[20] = pow(constants[1], 1.0/constants[0]) && (constants[2] > constants[3]); + computedConstants[21] = (constants[1] < constants[0]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[1] < constants[0]) && constants[2]; + computedConstants[23] = (constants[1] < constants[0]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[1] < constants[0]) && -constants[2]; + computedConstants[25] = (constants[1] < constants[0]) && pow(constants[2], constants[3]); + computedConstants[26] = (constants[1] < constants[0]) && pow(constants[2], 1.0/constants[3]); + computedConstants[27] = constants[1]/(constants[0] && constants[2]); + computedConstants[28] = constants[1] || constants[0]; + computedConstants[29] = constants[1] || constants[0] || constants[2]; + computedConstants[30] = (constants[1] < constants[0]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[1]+constants[0]) || (constants[2] > constants[3]); + computedConstants[32] = constants[1] || (constants[0] > constants[2]); + computedConstants[33] = (constants[1]-constants[0]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[1] || (constants[0] > constants[2]); + computedConstants[35] = pow(constants[1], constants[0]) || (constants[2] > constants[3]); + computedConstants[36] = pow(constants[1], 1.0/constants[0]) || (constants[2] > constants[3]); + computedConstants[37] = (constants[1] < constants[0]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[1] < constants[0]) || constants[2]; + computedConstants[39] = (constants[1] < constants[0]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[1] < constants[0]) || -constants[2]; + computedConstants[41] = (constants[1] < constants[0]) || pow(constants[2], constants[3]); + computedConstants[42] = (constants[1] < constants[0]) || pow(constants[2], 1.0/constants[3]); + computedConstants[43] = constants[1]/(constants[0] || constants[2]); + computedConstants[44] = xor(constants[1], constants[0]); + computedConstants[45] = xor(constants[1], xor(constants[0], constants[2])); + computedConstants[46] = xor(constants[1] < constants[0], constants[2] > constants[3]); + computedConstants[47] = xor(constants[1]+constants[0], constants[2] > constants[3]); + computedConstants[48] = xor(constants[1], constants[0] > constants[2]); + computedConstants[49] = xor(constants[1]-constants[0], constants[2] > constants[3]); + computedConstants[50] = xor(-constants[1], constants[0] > constants[2]); + computedConstants[51] = xor(pow(constants[1], constants[0]), constants[2] > constants[3]); + computedConstants[52] = xor(pow(constants[1], 1.0/constants[0]), constants[2] > constants[3]); + computedConstants[53] = xor(constants[1] < constants[0], constants[2]+constants[3]); + computedConstants[54] = xor(constants[1] < constants[0], constants[2]); + computedConstants[55] = xor(constants[1] < constants[0], constants[2]-constants[3]); + computedConstants[56] = xor(constants[1] < constants[0], -constants[2]); + computedConstants[57] = xor(constants[1] < constants[0], pow(constants[2], constants[3])); + computedConstants[58] = xor(constants[1] < constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[1]/xor(constants[0], constants[2]); + computedConstants[60] = !constants[1]; + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = (constants[1] < constants[0])+(constants[2] > constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = (constants[1] < constants[0])-(constants[2] > constants[3]); + computedConstants[66] = (constants[1] < constants[0])-(constants[2]+constants[3]); + computedConstants[67] = (constants[1] < constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -(constants[1] < constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = (constants[1] < constants[0])*(constants[2] > constants[3]); + computedConstants[75] = (constants[1]+constants[0])*(constants[2] > constants[3]); + computedConstants[76] = constants[1]*(constants[0] > constants[2]); + computedConstants[77] = (constants[1]-constants[0])*(constants[2] > constants[3]); + computedConstants[78] = -constants[1]*(constants[0] > constants[2]); + computedConstants[79] = (constants[1] < constants[0])*(constants[2]+constants[3]); + computedConstants[80] = (constants[1] < constants[0])*constants[2]; + computedConstants[81] = (constants[1] < constants[0])*(constants[2]-constants[3]); + computedConstants[82] = (constants[1] < constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = (constants[1] < constants[0])/(constants[3] > constants[2]); + computedConstants[85] = (constants[1]+constants[0])/(constants[3] > constants[2]); + computedConstants[86] = constants[1]/(constants[2] > constants[0]); + computedConstants[87] = (constants[1]-constants[0])/(constants[3] > constants[2]); + computedConstants[88] = -constants[1]/(constants[2] > constants[0]); + computedConstants[89] = (constants[1] < constants[0])/(constants[2]+constants[3]); + computedConstants[90] = (constants[1] < constants[0])/constants[2]; + computedConstants[91] = (constants[1] < constants[0])/(constants[2]-constants[3]); + computedConstants[92] = (constants[1] < constants[0])/-constants[2]; + computedConstants[93] = (constants[1] < constants[0])/(constants[2]*constants[3]); + computedConstants[94] = (constants[1] < constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = pow(constants[1], 2.0); + computedConstants[97] = pow(constants[1], 3.0); + computedConstants[98] = pow(constants[1], constants[0]); + computedConstants[99] = pow(constants[1] <= constants[0], constants[2] >= constants[3]); + computedConstants[100] = pow(constants[1]+constants[0], constants[2] >= constants[3]); + computedConstants[101] = pow(constants[1], constants[0] >= constants[2]); + computedConstants[102] = pow(constants[1]-constants[0], constants[2] >= constants[3]); + computedConstants[103] = pow(-constants[1], constants[0] >= constants[2]); + computedConstants[104] = pow(constants[1]*constants[0], constants[2] >= constants[3]); + computedConstants[105] = pow(constants[1]/constants[0], constants[2] >= constants[3]); + computedConstants[106] = pow(constants[1] <= constants[0], constants[2]+constants[3]); + computedConstants[107] = pow(constants[1] <= constants[0], constants[2]); + computedConstants[108] = pow(constants[1] <= constants[0], constants[2]-constants[3]); + computedConstants[109] = pow(constants[1] <= constants[0], -constants[2]); + computedConstants[110] = pow(constants[1] <= constants[0], constants[2]*constants[3]); + computedConstants[111] = pow(constants[1] <= constants[0], constants[2]/constants[3]); + computedConstants[112] = pow(constants[1] <= constants[0], pow(constants[2], constants[3])); + computedConstants[113] = pow(constants[1] <= constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = pow(constants[1], 1.0/3.0); + computedConstants[117] = pow(constants[1], 1.0/constants[0]); + computedConstants[118] = pow(constants[1] < constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[119] = pow(constants[1]+constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[120] = pow(constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[121] = pow(constants[1]-constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[122] = pow(-constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[123] = pow(constants[1]*constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[124] = pow(constants[1]/constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[125] = pow(constants[1] < constants[0], 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(constants[1] < constants[0], 1.0/constants[2]); + computedConstants[127] = pow(constants[1] < constants[0], 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(constants[1] < constants[0], 1.0/-constants[2]); + computedConstants[129] = pow(constants[1] < constants[0], 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(constants[1] < constants[0], 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(constants[1] < constants[0], 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(constants[1] < constants[0], 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = (constants[1] > constants[0])?constants[1]:NAN; + computedConstants[172] = (constants[1] > constants[0])?constants[1]:constants[2]; + computedConstants[173] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; + computedConstants[174] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; + computedConstants[175] = 123.0+((constants[1] > constants[0])?constants[1]:NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = (constants[1] && constants[0])+((constants[2] > constants[3])?constants[0]:NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[1] && constants[0])-(((constants[2] > constants[3])?constants[0]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[0]:NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[1] && constants[0])*((constants[2] > constants[3])?constants[0]:NAN)*constants[4]*((constants[2] > constants[3])?constants[0]:NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[1] && constants[0])/(((constants[2] > constants[3])?constants[0]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[0]:NAN))); + computedConstants[191] = (constants[1] || constants[0]) && xor(constants[1], constants[0]) && ((constants[2] > constants[3])?constants[0]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[0]:NAN) && xor(constants[1], constants[0]) && (constants[1] || constants[0]); + computedConstants[192] = (constants[1] && constants[0]) || xor(constants[1], constants[0]) || ((constants[2] > constants[3])?constants[0]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[0]:NAN) || xor(constants[1], constants[0]) || (constants[1] && constants[0]); + computedConstants[193] = xor(constants[1] && constants[0], xor(constants[1] || constants[0], xor((constants[2] > constants[3])?constants[0]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] || constants[0]), constants[1] && constants[0])))); + computedConstants[194] = pow(constants[1] && constants[0], pow((constants[2] > constants[3])?constants[0]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] && constants[0]))); + computedConstants[195] = pow(pow(pow(constants[1] && constants[0], 1.0/pow((constants[2] > constants[3])?constants[0]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[0]:NAN)), 1.0/(constants[1] && constants[0])); + computedConstants[196] = -(constants[1] && constants[0])+-((constants[2] > constants[3])?constants[0]:NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index ad759475d..f1d41b0e0 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -167,8 +167,8 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[0] = u[0]; algebraic[1] = u[1]; - f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; - f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); + f[0] = algebraic[1]+algebraic[0]+states[0]-0.0; + f[1] = algebraic[1]-algebraic[0]-(computedConstants[198]+computedConstants[197]); } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) @@ -188,8 +188,8 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; - constants[0] = 1.0; - constants[1] = 2.0; + constants[0] = 2.0; + constants[1] = 1.0; constants[2] = 3.0; constants[3] = 4.0; constants[4] = 5.0; @@ -205,201 +205,201 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[184] = 3.14159265358979; computedConstants[185] = INFINITY; computedConstants[186] = NAN; - computedConstants[197] = 1.0; - computedConstants[198] = 3.0; - algebraic[0] = 1.0; - algebraic[1] = 2.0; + computedConstants[198] = 1.0; + computedConstants[197] = 3.0; + algebraic[0] = 2.0; + algebraic[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = eq(constants[0], constants[1]); - computedConstants[1] = constants[0]/eq(constants[1], constants[1]); - computedConstants[2] = neq(constants[0], constants[1]); - computedConstants[3] = constants[0]/neq(constants[1], constants[2]); - computedConstants[4] = lt(constants[0], constants[1]); - computedConstants[5] = constants[0]/lt(constants[1], constants[2]); - computedConstants[6] = leq(constants[0], constants[1]); - computedConstants[7] = constants[0]/leq(constants[1], constants[2]); - computedConstants[8] = gt(constants[0], constants[1]); - computedConstants[9] = constants[0]/gt(constants[1], constants[2]); - computedConstants[10] = geq(constants[0], constants[1]); - computedConstants[11] = constants[0]/geq(constants[1], constants[2]); - computedConstants[12] = and(constants[0], constants[1]); - computedConstants[13] = and(constants[0], and(constants[1], constants[2])); - computedConstants[14] = and(lt(constants[0], constants[1]), gt(constants[2], constants[3])); - computedConstants[15] = and(constants[0]+constants[1], gt(constants[2], constants[3])); - computedConstants[16] = and(constants[0], gt(constants[1], constants[2])); - computedConstants[17] = and(constants[0]-constants[1], gt(constants[2], constants[3])); - computedConstants[18] = and(-constants[0], gt(constants[1], constants[2])); - computedConstants[19] = and(pow(constants[0], constants[1]), gt(constants[2], constants[3])); - computedConstants[20] = and(pow(constants[0], 1.0/constants[1]), gt(constants[2], constants[3])); - computedConstants[21] = and(lt(constants[0], constants[1]), constants[2]+constants[3]); - computedConstants[22] = and(lt(constants[0], constants[1]), constants[2]); - computedConstants[23] = and(lt(constants[0], constants[1]), constants[2]-constants[3]); - computedConstants[24] = and(lt(constants[0], constants[1]), -constants[2]); - computedConstants[25] = and(lt(constants[0], constants[1]), pow(constants[2], constants[3])); - computedConstants[26] = and(lt(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])); - computedConstants[27] = constants[0]/and(constants[1], constants[2]); - computedConstants[28] = or(constants[0], constants[1]); - computedConstants[29] = or(constants[0], or(constants[1], constants[2])); - computedConstants[30] = or(lt(constants[0], constants[1]), gt(constants[2], constants[3])); - computedConstants[31] = or(constants[0]+constants[1], gt(constants[2], constants[3])); - computedConstants[32] = or(constants[0], gt(constants[1], constants[2])); - computedConstants[33] = or(constants[0]-constants[1], gt(constants[2], constants[3])); - computedConstants[34] = or(-constants[0], gt(constants[1], constants[2])); - computedConstants[35] = or(pow(constants[0], constants[1]), gt(constants[2], constants[3])); - computedConstants[36] = or(pow(constants[0], 1.0/constants[1]), gt(constants[2], constants[3])); - computedConstants[37] = or(lt(constants[0], constants[1]), constants[2]+constants[3]); - computedConstants[38] = or(lt(constants[0], constants[1]), constants[2]); - computedConstants[39] = or(lt(constants[0], constants[1]), constants[2]-constants[3]); - computedConstants[40] = or(lt(constants[0], constants[1]), -constants[2]); - computedConstants[41] = or(lt(constants[0], constants[1]), pow(constants[2], constants[3])); - computedConstants[42] = or(lt(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])); - computedConstants[43] = constants[0]/or(constants[1], constants[2]); - computedConstants[44] = xor(constants[0], constants[1]); - computedConstants[45] = xor(constants[0], xor(constants[1], constants[2])); - computedConstants[46] = xor(lt(constants[0], constants[1]), gt(constants[2], constants[3])); - computedConstants[47] = xor(constants[0]+constants[1], gt(constants[2], constants[3])); - computedConstants[48] = xor(constants[0], gt(constants[1], constants[2])); - computedConstants[49] = xor(constants[0]-constants[1], gt(constants[2], constants[3])); - computedConstants[50] = xor(-constants[0], gt(constants[1], constants[2])); - computedConstants[51] = xor(pow(constants[0], constants[1]), gt(constants[2], constants[3])); - computedConstants[52] = xor(pow(constants[0], 1.0/constants[1]), gt(constants[2], constants[3])); - computedConstants[53] = xor(lt(constants[0], constants[1]), constants[2]+constants[3]); - computedConstants[54] = xor(lt(constants[0], constants[1]), constants[2]); - computedConstants[55] = xor(lt(constants[0], constants[1]), constants[2]-constants[3]); - computedConstants[56] = xor(lt(constants[0], constants[1]), -constants[2]); - computedConstants[57] = xor(lt(constants[0], constants[1]), pow(constants[2], constants[3])); - computedConstants[58] = xor(lt(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])); - computedConstants[59] = constants[0]/xor(constants[1], constants[2]); - computedConstants[60] = not(constants[0]); - computedConstants[61] = constants[0]+constants[1]+constants[2]; - computedConstants[62] = lt(constants[0], constants[1])+gt(constants[2], constants[3]); - computedConstants[63] = constants[0]; - computedConstants[64] = constants[0]-constants[1]; - computedConstants[65] = lt(constants[0], constants[1])-gt(constants[2], constants[3]); - computedConstants[66] = lt(constants[0], constants[1])-(constants[2]+constants[3]); - computedConstants[67] = lt(constants[0], constants[1])-constants[2]; - computedConstants[68] = constants[0]-(-constants[1]); - computedConstants[69] = constants[0]-(-constants[1]*constants[2]); - computedConstants[70] = -constants[0]; - computedConstants[71] = -lt(constants[0], constants[1]); - computedConstants[72] = constants[0]*constants[1]; - computedConstants[73] = constants[0]*constants[1]*constants[2]; - computedConstants[74] = lt(constants[0], constants[1])*gt(constants[2], constants[3]); - computedConstants[75] = (constants[0]+constants[1])*gt(constants[2], constants[3]); - computedConstants[76] = constants[0]*gt(constants[1], constants[2]); - computedConstants[77] = (constants[0]-constants[1])*gt(constants[2], constants[3]); - computedConstants[78] = -constants[0]*gt(constants[1], constants[2]); - computedConstants[79] = lt(constants[0], constants[1])*(constants[2]+constants[3]); - computedConstants[80] = lt(constants[0], constants[1])*constants[2]; - computedConstants[81] = lt(constants[0], constants[1])*(constants[2]-constants[3]); - computedConstants[82] = lt(constants[0], constants[1])*-constants[2]; - computedConstants[83] = constants[0]/constants[1]; - computedConstants[84] = lt(constants[0], constants[1])/gt(constants[3], constants[2]); - computedConstants[85] = (constants[0]+constants[1])/gt(constants[3], constants[2]); - computedConstants[86] = constants[0]/gt(constants[2], constants[1]); - computedConstants[87] = (constants[0]-constants[1])/gt(constants[3], constants[2]); - computedConstants[88] = -constants[0]/gt(constants[2], constants[1]); - computedConstants[89] = lt(constants[0], constants[1])/(constants[2]+constants[3]); - computedConstants[90] = lt(constants[0], constants[1])/constants[2]; - computedConstants[91] = lt(constants[0], constants[1])/(constants[2]-constants[3]); - computedConstants[92] = lt(constants[0], constants[1])/-constants[2]; - computedConstants[93] = lt(constants[0], constants[1])/(constants[2]*constants[3]); - computedConstants[94] = lt(constants[0], constants[1])/(constants[2]/constants[3]); - computedConstants[95] = sqrt(constants[0]); - computedConstants[96] = pow(constants[0], 2.0); - computedConstants[97] = pow(constants[0], 3.0); - computedConstants[98] = pow(constants[0], constants[1]); - computedConstants[99] = pow(leq(constants[0], constants[1]), geq(constants[2], constants[3])); - computedConstants[100] = pow(constants[0]+constants[1], geq(constants[2], constants[3])); - computedConstants[101] = pow(constants[0], geq(constants[1], constants[2])); - computedConstants[102] = pow(constants[0]-constants[1], geq(constants[2], constants[3])); - computedConstants[103] = pow(-constants[0], geq(constants[1], constants[2])); - computedConstants[104] = pow(constants[0]*constants[1], geq(constants[2], constants[3])); - computedConstants[105] = pow(constants[0]/constants[1], geq(constants[2], constants[3])); - computedConstants[106] = pow(leq(constants[0], constants[1]), constants[2]+constants[3]); - computedConstants[107] = pow(leq(constants[0], constants[1]), constants[2]); - computedConstants[108] = pow(leq(constants[0], constants[1]), constants[2]-constants[3]); - computedConstants[109] = pow(leq(constants[0], constants[1]), -constants[2]); - computedConstants[110] = pow(leq(constants[0], constants[1]), constants[2]*constants[3]); - computedConstants[111] = pow(leq(constants[0], constants[1]), constants[2]/constants[3]); - computedConstants[112] = pow(leq(constants[0], constants[1]), pow(constants[2], constants[3])); - computedConstants[113] = pow(leq(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])); - computedConstants[114] = sqrt(constants[0]); - computedConstants[115] = sqrt(constants[0]); - computedConstants[116] = pow(constants[0], 1.0/3.0); - computedConstants[117] = pow(constants[0], 1.0/constants[1]); - computedConstants[118] = pow(lt(constants[0], constants[1]), 1.0/gt(constants[3], constants[2])); - computedConstants[119] = pow(constants[0]+constants[1], 1.0/gt(constants[3], constants[2])); - computedConstants[120] = pow(constants[0], 1.0/gt(constants[2], constants[1])); - computedConstants[121] = pow(constants[0]-constants[1], 1.0/gt(constants[3], constants[2])); - computedConstants[122] = pow(-constants[0], 1.0/gt(constants[2], constants[1])); - computedConstants[123] = pow(constants[0]*constants[1], 1.0/gt(constants[3], constants[2])); - computedConstants[124] = pow(constants[0]/constants[1], 1.0/gt(constants[3], constants[2])); - computedConstants[125] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]+constants[3])); - computedConstants[126] = pow(lt(constants[0], constants[1]), 1.0/constants[2]); - computedConstants[127] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]-constants[3])); - computedConstants[128] = pow(lt(constants[0], constants[1]), 1.0/-constants[2]); - computedConstants[129] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]*constants[3])); - computedConstants[130] = pow(lt(constants[0], constants[1]), 1.0/(constants[2]/constants[3])); - computedConstants[131] = pow(lt(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])); - computedConstants[132] = pow(lt(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])); - computedConstants[133] = fabs(constants[0]); - computedConstants[134] = exp(constants[0]); - computedConstants[135] = log(constants[0]); - computedConstants[136] = log10(constants[0]); - computedConstants[137] = log(constants[0])/log(2.0); - computedConstants[138] = log10(constants[0]); - computedConstants[139] = log(constants[0])/log(constants[1]); - computedConstants[140] = ceil(constants[0]); - computedConstants[141] = floor(constants[0]); - computedConstants[142] = min(constants[0], constants[1]); - computedConstants[143] = min(constants[0], min(constants[1], constants[2])); - computedConstants[144] = max(constants[0], constants[1]); - computedConstants[145] = max(constants[0], max(constants[1], constants[2])); - computedConstants[146] = fmod(constants[0], constants[1]); - computedConstants[147] = sin(constants[0]); - computedConstants[148] = cos(constants[0]); - computedConstants[149] = tan(constants[0]); - computedConstants[150] = sec(constants[0]); - computedConstants[151] = csc(constants[0]); - computedConstants[152] = cot(constants[0]); - computedConstants[153] = sinh(constants[0]); - computedConstants[154] = cosh(constants[0]); - computedConstants[155] = tanh(constants[0]); - computedConstants[156] = sech(constants[0]); - computedConstants[157] = csch(constants[0]); - computedConstants[158] = coth(constants[0]); - computedConstants[159] = asin(constants[0]); - computedConstants[160] = acos(constants[0]); - computedConstants[161] = atan(constants[0]); - computedConstants[162] = asec(constants[0]); - computedConstants[163] = acsc(constants[0]); - computedConstants[164] = acot(constants[0]); - computedConstants[165] = asinh(constants[0]); - computedConstants[166] = acosh(constants[0]); - computedConstants[167] = atanh(constants[0]/2.0); - computedConstants[168] = asech(constants[0]); - computedConstants[169] = acsch(constants[0]); - computedConstants[170] = acoth(2.0*constants[0]); - computedConstants[171] = (gt(constants[0], constants[1]))?constants[0]:NAN; - computedConstants[172] = (gt(constants[0], constants[1]))?constants[0]:constants[2]; - computedConstants[173] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:NAN; - computedConstants[174] = (gt(constants[0], constants[1]))?constants[0]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:constants[6]; - computedConstants[175] = 123.0+((gt(constants[0], constants[1]))?constants[0]:NAN); - computedConstants[180] = constants[0]; - computedConstants[187] = and(constants[0], constants[1])+((gt(constants[2], constants[3]))?constants[1]:NAN)+constants[4]+and(constants[5], constants[6]); - computedConstants[188] = and(constants[0], constants[1])-(((gt(constants[2], constants[3]))?constants[1]:NAN)-(constants[4]-((gt(constants[2], constants[3]))?constants[1]:NAN)))-and(constants[5], constants[6]); - computedConstants[189] = and(constants[0], constants[1])*((gt(constants[2], constants[3]))?constants[1]:NAN)*constants[4]*((gt(constants[2], constants[3]))?constants[1]:NAN)*and(constants[5], constants[6]); - computedConstants[190] = and(constants[0], constants[1])/(((gt(constants[2], constants[3]))?constants[1]:NAN)/(constants[4]/((gt(constants[2], constants[3]))?constants[1]:NAN))); - computedConstants[191] = and(or(constants[0], constants[1]), and(xor(constants[0], constants[1]), and((gt(constants[2], constants[3]))?constants[1]:NAN, and(and(and(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), xor(constants[0], constants[1])), or(constants[0], constants[1]))))); - computedConstants[192] = or(and(constants[0], constants[1]), or(xor(constants[0], constants[1]), or((gt(constants[2], constants[3]))?constants[1]:NAN, or(or(or(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), xor(constants[0], constants[1])), and(constants[0], constants[1]))))); - computedConstants[193] = xor(and(constants[0], constants[1]), xor(or(constants[0], constants[1]), xor((gt(constants[2], constants[3]))?constants[1]:NAN, xor(xor(xor(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), or(constants[0], constants[1])), and(constants[0], constants[1]))))); - computedConstants[194] = pow(and(constants[0], constants[1]), pow((gt(constants[2], constants[3]))?constants[1]:NAN, pow(pow(constants[4], (gt(constants[2], constants[3]))?constants[1]:NAN), and(constants[0], constants[1])))); - computedConstants[195] = pow(pow(pow(and(constants[0], constants[1]), 1.0/pow((gt(constants[2], constants[3]))?constants[1]:NAN, 1.0/constants[4])), 1.0/((gt(constants[2], constants[3]))?constants[1]:NAN)), 1.0/and(constants[0], constants[1])); - computedConstants[196] = -and(constants[0], constants[1])+-((gt(constants[2], constants[3]))?constants[1]:NAN); + computedConstants[0] = eq(constants[1], constants[0]); + computedConstants[1] = constants[1]/eq(constants[0], constants[0]); + computedConstants[2] = neq(constants[1], constants[0]); + computedConstants[3] = constants[1]/neq(constants[0], constants[2]); + computedConstants[4] = lt(constants[1], constants[0]); + computedConstants[5] = constants[1]/lt(constants[0], constants[2]); + computedConstants[6] = leq(constants[1], constants[0]); + computedConstants[7] = constants[1]/leq(constants[0], constants[2]); + computedConstants[8] = gt(constants[1], constants[0]); + computedConstants[9] = constants[1]/gt(constants[0], constants[2]); + computedConstants[10] = geq(constants[1], constants[0]); + computedConstants[11] = constants[1]/geq(constants[0], constants[2]); + computedConstants[12] = and(constants[1], constants[0]); + computedConstants[13] = and(constants[1], and(constants[0], constants[2])); + computedConstants[14] = and(lt(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[15] = and(constants[1]+constants[0], gt(constants[2], constants[3])); + computedConstants[16] = and(constants[1], gt(constants[0], constants[2])); + computedConstants[17] = and(constants[1]-constants[0], gt(constants[2], constants[3])); + computedConstants[18] = and(-constants[1], gt(constants[0], constants[2])); + computedConstants[19] = and(pow(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[20] = and(pow(constants[1], 1.0/constants[0]), gt(constants[2], constants[3])); + computedConstants[21] = and(lt(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[22] = and(lt(constants[1], constants[0]), constants[2]); + computedConstants[23] = and(lt(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[24] = and(lt(constants[1], constants[0]), -constants[2]); + computedConstants[25] = and(lt(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[26] = and(lt(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[27] = constants[1]/and(constants[0], constants[2]); + computedConstants[28] = or(constants[1], constants[0]); + computedConstants[29] = or(constants[1], or(constants[0], constants[2])); + computedConstants[30] = or(lt(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[31] = or(constants[1]+constants[0], gt(constants[2], constants[3])); + computedConstants[32] = or(constants[1], gt(constants[0], constants[2])); + computedConstants[33] = or(constants[1]-constants[0], gt(constants[2], constants[3])); + computedConstants[34] = or(-constants[1], gt(constants[0], constants[2])); + computedConstants[35] = or(pow(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[36] = or(pow(constants[1], 1.0/constants[0]), gt(constants[2], constants[3])); + computedConstants[37] = or(lt(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[38] = or(lt(constants[1], constants[0]), constants[2]); + computedConstants[39] = or(lt(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[40] = or(lt(constants[1], constants[0]), -constants[2]); + computedConstants[41] = or(lt(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[42] = or(lt(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[43] = constants[1]/or(constants[0], constants[2]); + computedConstants[44] = xor(constants[1], constants[0]); + computedConstants[45] = xor(constants[1], xor(constants[0], constants[2])); + computedConstants[46] = xor(lt(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[47] = xor(constants[1]+constants[0], gt(constants[2], constants[3])); + computedConstants[48] = xor(constants[1], gt(constants[0], constants[2])); + computedConstants[49] = xor(constants[1]-constants[0], gt(constants[2], constants[3])); + computedConstants[50] = xor(-constants[1], gt(constants[0], constants[2])); + computedConstants[51] = xor(pow(constants[1], constants[0]), gt(constants[2], constants[3])); + computedConstants[52] = xor(pow(constants[1], 1.0/constants[0]), gt(constants[2], constants[3])); + computedConstants[53] = xor(lt(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[54] = xor(lt(constants[1], constants[0]), constants[2]); + computedConstants[55] = xor(lt(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[56] = xor(lt(constants[1], constants[0]), -constants[2]); + computedConstants[57] = xor(lt(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[58] = xor(lt(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[1]/xor(constants[0], constants[2]); + computedConstants[60] = not(constants[1]); + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = lt(constants[1], constants[0])+gt(constants[2], constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = lt(constants[1], constants[0])-gt(constants[2], constants[3]); + computedConstants[66] = lt(constants[1], constants[0])-(constants[2]+constants[3]); + computedConstants[67] = lt(constants[1], constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -lt(constants[1], constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = lt(constants[1], constants[0])*gt(constants[2], constants[3]); + computedConstants[75] = (constants[1]+constants[0])*gt(constants[2], constants[3]); + computedConstants[76] = constants[1]*gt(constants[0], constants[2]); + computedConstants[77] = (constants[1]-constants[0])*gt(constants[2], constants[3]); + computedConstants[78] = -constants[1]*gt(constants[0], constants[2]); + computedConstants[79] = lt(constants[1], constants[0])*(constants[2]+constants[3]); + computedConstants[80] = lt(constants[1], constants[0])*constants[2]; + computedConstants[81] = lt(constants[1], constants[0])*(constants[2]-constants[3]); + computedConstants[82] = lt(constants[1], constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = lt(constants[1], constants[0])/gt(constants[3], constants[2]); + computedConstants[85] = (constants[1]+constants[0])/gt(constants[3], constants[2]); + computedConstants[86] = constants[1]/gt(constants[2], constants[0]); + computedConstants[87] = (constants[1]-constants[0])/gt(constants[3], constants[2]); + computedConstants[88] = -constants[1]/gt(constants[2], constants[0]); + computedConstants[89] = lt(constants[1], constants[0])/(constants[2]+constants[3]); + computedConstants[90] = lt(constants[1], constants[0])/constants[2]; + computedConstants[91] = lt(constants[1], constants[0])/(constants[2]-constants[3]); + computedConstants[92] = lt(constants[1], constants[0])/-constants[2]; + computedConstants[93] = lt(constants[1], constants[0])/(constants[2]*constants[3]); + computedConstants[94] = lt(constants[1], constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = pow(constants[1], 2.0); + computedConstants[97] = pow(constants[1], 3.0); + computedConstants[98] = pow(constants[1], constants[0]); + computedConstants[99] = pow(leq(constants[1], constants[0]), geq(constants[2], constants[3])); + computedConstants[100] = pow(constants[1]+constants[0], geq(constants[2], constants[3])); + computedConstants[101] = pow(constants[1], geq(constants[0], constants[2])); + computedConstants[102] = pow(constants[1]-constants[0], geq(constants[2], constants[3])); + computedConstants[103] = pow(-constants[1], geq(constants[0], constants[2])); + computedConstants[104] = pow(constants[1]*constants[0], geq(constants[2], constants[3])); + computedConstants[105] = pow(constants[1]/constants[0], geq(constants[2], constants[3])); + computedConstants[106] = pow(leq(constants[1], constants[0]), constants[2]+constants[3]); + computedConstants[107] = pow(leq(constants[1], constants[0]), constants[2]); + computedConstants[108] = pow(leq(constants[1], constants[0]), constants[2]-constants[3]); + computedConstants[109] = pow(leq(constants[1], constants[0]), -constants[2]); + computedConstants[110] = pow(leq(constants[1], constants[0]), constants[2]*constants[3]); + computedConstants[111] = pow(leq(constants[1], constants[0]), constants[2]/constants[3]); + computedConstants[112] = pow(leq(constants[1], constants[0]), pow(constants[2], constants[3])); + computedConstants[113] = pow(leq(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = pow(constants[1], 1.0/3.0); + computedConstants[117] = pow(constants[1], 1.0/constants[0]); + computedConstants[118] = pow(lt(constants[1], constants[0]), 1.0/gt(constants[3], constants[2])); + computedConstants[119] = pow(constants[1]+constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[120] = pow(constants[1], 1.0/gt(constants[2], constants[0])); + computedConstants[121] = pow(constants[1]-constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[122] = pow(-constants[1], 1.0/gt(constants[2], constants[0])); + computedConstants[123] = pow(constants[1]*constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[124] = pow(constants[1]/constants[0], 1.0/gt(constants[3], constants[2])); + computedConstants[125] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(lt(constants[1], constants[0]), 1.0/constants[2]); + computedConstants[127] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(lt(constants[1], constants[0]), 1.0/-constants[2]); + computedConstants[129] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(lt(constants[1], constants[0]), 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(lt(constants[1], constants[0]), 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(lt(constants[1], constants[0]), 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = (gt(constants[1], constants[0]))?constants[1]:NAN; + computedConstants[172] = (gt(constants[1], constants[0]))?constants[1]:constants[2]; + computedConstants[173] = (gt(constants[1], constants[0]))?constants[1]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:NAN; + computedConstants[174] = (gt(constants[1], constants[0]))?constants[1]:(gt(constants[2], constants[3]))?constants[2]:(gt(constants[4], constants[5]))?constants[4]:constants[6]; + computedConstants[175] = 123.0+((gt(constants[1], constants[0]))?constants[1]:NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = and(constants[1], constants[0])+((gt(constants[2], constants[3]))?constants[0]:NAN)+constants[4]+and(constants[5], constants[6]); + computedConstants[188] = and(constants[1], constants[0])-(((gt(constants[2], constants[3]))?constants[0]:NAN)-(constants[4]-((gt(constants[2], constants[3]))?constants[0]:NAN)))-and(constants[5], constants[6]); + computedConstants[189] = and(constants[1], constants[0])*((gt(constants[2], constants[3]))?constants[0]:NAN)*constants[4]*((gt(constants[2], constants[3]))?constants[0]:NAN)*and(constants[5], constants[6]); + computedConstants[190] = and(constants[1], constants[0])/(((gt(constants[2], constants[3]))?constants[0]:NAN)/(constants[4]/((gt(constants[2], constants[3]))?constants[0]:NAN))); + computedConstants[191] = and(or(constants[1], constants[0]), and(xor(constants[1], constants[0]), and((gt(constants[2], constants[3]))?constants[0]:NAN, and(and(and(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), xor(constants[1], constants[0])), or(constants[1], constants[0]))))); + computedConstants[192] = or(and(constants[1], constants[0]), or(xor(constants[1], constants[0]), or((gt(constants[2], constants[3]))?constants[0]:NAN, or(or(or(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), xor(constants[1], constants[0])), and(constants[1], constants[0]))))); + computedConstants[193] = xor(and(constants[1], constants[0]), xor(or(constants[1], constants[0]), xor((gt(constants[2], constants[3]))?constants[0]:NAN, xor(xor(xor(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), or(constants[1], constants[0])), and(constants[1], constants[0]))))); + computedConstants[194] = pow(and(constants[1], constants[0]), pow((gt(constants[2], constants[3]))?constants[0]:NAN, pow(pow(constants[4], (gt(constants[2], constants[3]))?constants[0]:NAN), and(constants[1], constants[0])))); + computedConstants[195] = pow(pow(pow(and(constants[1], constants[0]), 1.0/pow((gt(constants[2], constants[3]))?constants[0]:NAN, 1.0/constants[4])), 1.0/((gt(constants[2], constants[3]))?constants[0]:NAN)), 1.0/and(constants[1], constants[0])); + computedConstants[196] = -and(constants[1], constants[0])+-((gt(constants[2], constants[3]))?constants[0]:NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 0548a6ab7..fe91f3410 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -21,8 +21,8 @@ const VariableInfo STATE_INFO[] = { }; const VariableInfo CONSTANT_INFO[] = { - {"m", "dimensionless", "my_component"}, {"n", "dimensionless", "my_component"}, + {"m", "dimensionless", "my_component"}, {"o", "dimensionless", "my_component"}, {"p", "dimensionless", "my_component"}, {"q", "dimensionless", "my_component"}, @@ -228,13 +228,13 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"eqnCoverageForPowerOperator", "dimensionless", "my_component"}, {"eqnCoverageForRootOperator", "dimensionless", "my_component"}, {"eqnCoverageForMinusUnary", "dimensionless", "my_component"}, - {"eqnComputedConstant1", "dimensionless", "my_component"}, - {"eqnComputedConstant2", "dimensionless", "my_component"} + {"eqnComputedConstant2", "dimensionless", "my_component"}, + {"eqnComputedConstant1", "dimensionless", "my_component"} }; const VariableInfo ALGEBRAIC_INFO[] = { - {"eqnNlaVariable1", "dimensionless", "my_component"}, - {"eqnNlaVariable2", "dimensionless", "my_component"} + {"eqnNlaVariable2", "dimensionless", "my_component"}, + {"eqnNlaVariable1", "dimensionless", "my_component"} }; const VariableInfo EXTERNAL_INFO[] = { @@ -408,8 +408,8 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[0] = u[0]; algebraic[1] = u[1]; - f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; - f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); + f[0] = algebraic[1]+algebraic[0]+states[0]-0.0; + f[1] = algebraic[1]-algebraic[0]-(computedConstants[198]+computedConstants[197]); } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) @@ -429,8 +429,8 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = 0.0; - constants[0] = 1.0; - constants[1] = 2.0; + constants[0] = 2.0; + constants[1] = 1.0; constants[2] = 3.0; constants[3] = 4.0; constants[4] = 5.0; @@ -446,201 +446,201 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[184] = 3.14159265358979; computedConstants[185] = INFINITY; computedConstants[186] = NAN; - computedConstants[197] = 1.0; - computedConstants[198] = 3.0; - algebraic[0] = 1.0; - algebraic[1] = 2.0; + computedConstants[198] = 1.0; + computedConstants[197] = 3.0; + algebraic[0] = 2.0; + algebraic[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = constants[0] == constants[1]; - computedConstants[1] = constants[0]/(constants[1] == constants[1]); - computedConstants[2] = constants[0] != constants[1]; - computedConstants[3] = constants[0]/(constants[1] != constants[2]); - computedConstants[4] = constants[0] < constants[1]; - computedConstants[5] = constants[0]/(constants[1] < constants[2]); - computedConstants[6] = constants[0] <= constants[1]; - computedConstants[7] = constants[0]/(constants[1] <= constants[2]); - computedConstants[8] = constants[0] > constants[1]; - computedConstants[9] = constants[0]/(constants[1] > constants[2]); - computedConstants[10] = constants[0] >= constants[1]; - computedConstants[11] = constants[0]/(constants[1] >= constants[2]); - computedConstants[12] = constants[0] && constants[1]; - computedConstants[13] = constants[0] && constants[1] && constants[2]; - computedConstants[14] = (constants[0] < constants[1]) && (constants[2] > constants[3]); - computedConstants[15] = (constants[0]+constants[1]) && (constants[2] > constants[3]); - computedConstants[16] = constants[0] && (constants[1] > constants[2]); - computedConstants[17] = (constants[0]-constants[1]) && (constants[2] > constants[3]); - computedConstants[18] = -constants[0] && (constants[1] > constants[2]); - computedConstants[19] = pow(constants[0], constants[1]) && (constants[2] > constants[3]); - computedConstants[20] = pow(constants[0], 1.0/constants[1]) && (constants[2] > constants[3]); - computedConstants[21] = (constants[0] < constants[1]) && (constants[2]+constants[3]); - computedConstants[22] = (constants[0] < constants[1]) && constants[2]; - computedConstants[23] = (constants[0] < constants[1]) && (constants[2]-constants[3]); - computedConstants[24] = (constants[0] < constants[1]) && -constants[2]; - computedConstants[25] = (constants[0] < constants[1]) && pow(constants[2], constants[3]); - computedConstants[26] = (constants[0] < constants[1]) && pow(constants[2], 1.0/constants[3]); - computedConstants[27] = constants[0]/(constants[1] && constants[2]); - computedConstants[28] = constants[0] || constants[1]; - computedConstants[29] = constants[0] || constants[1] || constants[2]; - computedConstants[30] = (constants[0] < constants[1]) || (constants[2] > constants[3]); - computedConstants[31] = (constants[0]+constants[1]) || (constants[2] > constants[3]); - computedConstants[32] = constants[0] || (constants[1] > constants[2]); - computedConstants[33] = (constants[0]-constants[1]) || (constants[2] > constants[3]); - computedConstants[34] = -constants[0] || (constants[1] > constants[2]); - computedConstants[35] = pow(constants[0], constants[1]) || (constants[2] > constants[3]); - computedConstants[36] = pow(constants[0], 1.0/constants[1]) || (constants[2] > constants[3]); - computedConstants[37] = (constants[0] < constants[1]) || (constants[2]+constants[3]); - computedConstants[38] = (constants[0] < constants[1]) || constants[2]; - computedConstants[39] = (constants[0] < constants[1]) || (constants[2]-constants[3]); - computedConstants[40] = (constants[0] < constants[1]) || -constants[2]; - computedConstants[41] = (constants[0] < constants[1]) || pow(constants[2], constants[3]); - computedConstants[42] = (constants[0] < constants[1]) || pow(constants[2], 1.0/constants[3]); - computedConstants[43] = constants[0]/(constants[1] || constants[2]); - computedConstants[44] = xor(constants[0], constants[1]); - computedConstants[45] = xor(constants[0], xor(constants[1], constants[2])); - computedConstants[46] = xor(constants[0] < constants[1], constants[2] > constants[3]); - computedConstants[47] = xor(constants[0]+constants[1], constants[2] > constants[3]); - computedConstants[48] = xor(constants[0], constants[1] > constants[2]); - computedConstants[49] = xor(constants[0]-constants[1], constants[2] > constants[3]); - computedConstants[50] = xor(-constants[0], constants[1] > constants[2]); - computedConstants[51] = xor(pow(constants[0], constants[1]), constants[2] > constants[3]); - computedConstants[52] = xor(pow(constants[0], 1.0/constants[1]), constants[2] > constants[3]); - computedConstants[53] = xor(constants[0] < constants[1], constants[2]+constants[3]); - computedConstants[54] = xor(constants[0] < constants[1], constants[2]); - computedConstants[55] = xor(constants[0] < constants[1], constants[2]-constants[3]); - computedConstants[56] = xor(constants[0] < constants[1], -constants[2]); - computedConstants[57] = xor(constants[0] < constants[1], pow(constants[2], constants[3])); - computedConstants[58] = xor(constants[0] < constants[1], pow(constants[2], 1.0/constants[3])); - computedConstants[59] = constants[0]/xor(constants[1], constants[2]); - computedConstants[60] = !constants[0]; - computedConstants[61] = constants[0]+constants[1]+constants[2]; - computedConstants[62] = (constants[0] < constants[1])+(constants[2] > constants[3]); - computedConstants[63] = constants[0]; - computedConstants[64] = constants[0]-constants[1]; - computedConstants[65] = (constants[0] < constants[1])-(constants[2] > constants[3]); - computedConstants[66] = (constants[0] < constants[1])-(constants[2]+constants[3]); - computedConstants[67] = (constants[0] < constants[1])-constants[2]; - computedConstants[68] = constants[0]-(-constants[1]); - computedConstants[69] = constants[0]-(-constants[1]*constants[2]); - computedConstants[70] = -constants[0]; - computedConstants[71] = -(constants[0] < constants[1]); - computedConstants[72] = constants[0]*constants[1]; - computedConstants[73] = constants[0]*constants[1]*constants[2]; - computedConstants[74] = (constants[0] < constants[1])*(constants[2] > constants[3]); - computedConstants[75] = (constants[0]+constants[1])*(constants[2] > constants[3]); - computedConstants[76] = constants[0]*(constants[1] > constants[2]); - computedConstants[77] = (constants[0]-constants[1])*(constants[2] > constants[3]); - computedConstants[78] = -constants[0]*(constants[1] > constants[2]); - computedConstants[79] = (constants[0] < constants[1])*(constants[2]+constants[3]); - computedConstants[80] = (constants[0] < constants[1])*constants[2]; - computedConstants[81] = (constants[0] < constants[1])*(constants[2]-constants[3]); - computedConstants[82] = (constants[0] < constants[1])*-constants[2]; - computedConstants[83] = constants[0]/constants[1]; - computedConstants[84] = (constants[0] < constants[1])/(constants[3] > constants[2]); - computedConstants[85] = (constants[0]+constants[1])/(constants[3] > constants[2]); - computedConstants[86] = constants[0]/(constants[2] > constants[1]); - computedConstants[87] = (constants[0]-constants[1])/(constants[3] > constants[2]); - computedConstants[88] = -constants[0]/(constants[2] > constants[1]); - computedConstants[89] = (constants[0] < constants[1])/(constants[2]+constants[3]); - computedConstants[90] = (constants[0] < constants[1])/constants[2]; - computedConstants[91] = (constants[0] < constants[1])/(constants[2]-constants[3]); - computedConstants[92] = (constants[0] < constants[1])/-constants[2]; - computedConstants[93] = (constants[0] < constants[1])/(constants[2]*constants[3]); - computedConstants[94] = (constants[0] < constants[1])/(constants[2]/constants[3]); - computedConstants[95] = sqrt(constants[0]); - computedConstants[96] = pow(constants[0], 2.0); - computedConstants[97] = pow(constants[0], 3.0); - computedConstants[98] = pow(constants[0], constants[1]); - computedConstants[99] = pow(constants[0] <= constants[1], constants[2] >= constants[3]); - computedConstants[100] = pow(constants[0]+constants[1], constants[2] >= constants[3]); - computedConstants[101] = pow(constants[0], constants[1] >= constants[2]); - computedConstants[102] = pow(constants[0]-constants[1], constants[2] >= constants[3]); - computedConstants[103] = pow(-constants[0], constants[1] >= constants[2]); - computedConstants[104] = pow(constants[0]*constants[1], constants[2] >= constants[3]); - computedConstants[105] = pow(constants[0]/constants[1], constants[2] >= constants[3]); - computedConstants[106] = pow(constants[0] <= constants[1], constants[2]+constants[3]); - computedConstants[107] = pow(constants[0] <= constants[1], constants[2]); - computedConstants[108] = pow(constants[0] <= constants[1], constants[2]-constants[3]); - computedConstants[109] = pow(constants[0] <= constants[1], -constants[2]); - computedConstants[110] = pow(constants[0] <= constants[1], constants[2]*constants[3]); - computedConstants[111] = pow(constants[0] <= constants[1], constants[2]/constants[3]); - computedConstants[112] = pow(constants[0] <= constants[1], pow(constants[2], constants[3])); - computedConstants[113] = pow(constants[0] <= constants[1], pow(constants[2], 1.0/constants[3])); - computedConstants[114] = sqrt(constants[0]); - computedConstants[115] = sqrt(constants[0]); - computedConstants[116] = pow(constants[0], 1.0/3.0); - computedConstants[117] = pow(constants[0], 1.0/constants[1]); - computedConstants[118] = pow(constants[0] < constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[119] = pow(constants[0]+constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[120] = pow(constants[0], 1.0/(constants[2] > constants[1])); - computedConstants[121] = pow(constants[0]-constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[122] = pow(-constants[0], 1.0/(constants[2] > constants[1])); - computedConstants[123] = pow(constants[0]*constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[124] = pow(constants[0]/constants[1], 1.0/(constants[3] > constants[2])); - computedConstants[125] = pow(constants[0] < constants[1], 1.0/(constants[2]+constants[3])); - computedConstants[126] = pow(constants[0] < constants[1], 1.0/constants[2]); - computedConstants[127] = pow(constants[0] < constants[1], 1.0/(constants[2]-constants[3])); - computedConstants[128] = pow(constants[0] < constants[1], 1.0/-constants[2]); - computedConstants[129] = pow(constants[0] < constants[1], 1.0/(constants[2]*constants[3])); - computedConstants[130] = pow(constants[0] < constants[1], 1.0/(constants[2]/constants[3])); - computedConstants[131] = pow(constants[0] < constants[1], 1.0/pow(constants[2], constants[3])); - computedConstants[132] = pow(constants[0] < constants[1], 1.0/pow(constants[2], 1.0/constants[3])); - computedConstants[133] = fabs(constants[0]); - computedConstants[134] = exp(constants[0]); - computedConstants[135] = log(constants[0]); - computedConstants[136] = log10(constants[0]); - computedConstants[137] = log(constants[0])/log(2.0); - computedConstants[138] = log10(constants[0]); - computedConstants[139] = log(constants[0])/log(constants[1]); - computedConstants[140] = ceil(constants[0]); - computedConstants[141] = floor(constants[0]); - computedConstants[142] = min(constants[0], constants[1]); - computedConstants[143] = min(constants[0], min(constants[1], constants[2])); - computedConstants[144] = max(constants[0], constants[1]); - computedConstants[145] = max(constants[0], max(constants[1], constants[2])); - computedConstants[146] = fmod(constants[0], constants[1]); - computedConstants[147] = sin(constants[0]); - computedConstants[148] = cos(constants[0]); - computedConstants[149] = tan(constants[0]); - computedConstants[150] = sec(constants[0]); - computedConstants[151] = csc(constants[0]); - computedConstants[152] = cot(constants[0]); - computedConstants[153] = sinh(constants[0]); - computedConstants[154] = cosh(constants[0]); - computedConstants[155] = tanh(constants[0]); - computedConstants[156] = sech(constants[0]); - computedConstants[157] = csch(constants[0]); - computedConstants[158] = coth(constants[0]); - computedConstants[159] = asin(constants[0]); - computedConstants[160] = acos(constants[0]); - computedConstants[161] = atan(constants[0]); - computedConstants[162] = asec(constants[0]); - computedConstants[163] = acsc(constants[0]); - computedConstants[164] = acot(constants[0]); - computedConstants[165] = asinh(constants[0]); - computedConstants[166] = acosh(constants[0]); - computedConstants[167] = atanh(constants[0]/2.0); - computedConstants[168] = asech(constants[0]); - computedConstants[169] = acsch(constants[0]); - computedConstants[170] = acoth(2.0*constants[0]); - computedConstants[171] = (constants[0] > constants[1])?constants[0]:NAN; - computedConstants[172] = (constants[0] > constants[1])?constants[0]:constants[2]; - computedConstants[173] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; - computedConstants[174] = (constants[0] > constants[1])?constants[0]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; - computedConstants[175] = 123.0+((constants[0] > constants[1])?constants[0]:NAN); - computedConstants[180] = constants[0]; - computedConstants[187] = (constants[0] && constants[1])+((constants[2] > constants[3])?constants[1]:NAN)+constants[4]+(constants[5] && constants[6]); - computedConstants[188] = (constants[0] && constants[1])-(((constants[2] > constants[3])?constants[1]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[1]:NAN)))-(constants[5] && constants[6]); - computedConstants[189] = (constants[0] && constants[1])*((constants[2] > constants[3])?constants[1]:NAN)*constants[4]*((constants[2] > constants[3])?constants[1]:NAN)*(constants[5] && constants[6]); - computedConstants[190] = (constants[0] && constants[1])/(((constants[2] > constants[3])?constants[1]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[1]:NAN))); - computedConstants[191] = (constants[0] || constants[1]) && xor(constants[0], constants[1]) && ((constants[2] > constants[3])?constants[1]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[1]:NAN) && xor(constants[0], constants[1]) && (constants[0] || constants[1]); - computedConstants[192] = (constants[0] && constants[1]) || xor(constants[0], constants[1]) || ((constants[2] > constants[3])?constants[1]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[1]:NAN) || xor(constants[0], constants[1]) || (constants[0] && constants[1]); - computedConstants[193] = xor(constants[0] && constants[1], xor(constants[0] || constants[1], xor((constants[2] > constants[3])?constants[1]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] || constants[1]), constants[0] && constants[1])))); - computedConstants[194] = pow(constants[0] && constants[1], pow((constants[2] > constants[3])?constants[1]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[1]:NAN), constants[0] && constants[1]))); - computedConstants[195] = pow(pow(pow(constants[0] && constants[1], 1.0/pow((constants[2] > constants[3])?constants[1]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[1]:NAN)), 1.0/(constants[0] && constants[1])); - computedConstants[196] = -(constants[0] && constants[1])+-((constants[2] > constants[3])?constants[1]:NAN); + computedConstants[0] = constants[1] == constants[0]; + computedConstants[1] = constants[1]/(constants[0] == constants[0]); + computedConstants[2] = constants[1] != constants[0]; + computedConstants[3] = constants[1]/(constants[0] != constants[2]); + computedConstants[4] = constants[1] < constants[0]; + computedConstants[5] = constants[1]/(constants[0] < constants[2]); + computedConstants[6] = constants[1] <= constants[0]; + computedConstants[7] = constants[1]/(constants[0] <= constants[2]); + computedConstants[8] = constants[1] > constants[0]; + computedConstants[9] = constants[1]/(constants[0] > constants[2]); + computedConstants[10] = constants[1] >= constants[0]; + computedConstants[11] = constants[1]/(constants[0] >= constants[2]); + computedConstants[12] = constants[1] && constants[0]; + computedConstants[13] = constants[1] && constants[0] && constants[2]; + computedConstants[14] = (constants[1] < constants[0]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[1]+constants[0]) && (constants[2] > constants[3]); + computedConstants[16] = constants[1] && (constants[0] > constants[2]); + computedConstants[17] = (constants[1]-constants[0]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[1] && (constants[0] > constants[2]); + computedConstants[19] = pow(constants[1], constants[0]) && (constants[2] > constants[3]); + computedConstants[20] = pow(constants[1], 1.0/constants[0]) && (constants[2] > constants[3]); + computedConstants[21] = (constants[1] < constants[0]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[1] < constants[0]) && constants[2]; + computedConstants[23] = (constants[1] < constants[0]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[1] < constants[0]) && -constants[2]; + computedConstants[25] = (constants[1] < constants[0]) && pow(constants[2], constants[3]); + computedConstants[26] = (constants[1] < constants[0]) && pow(constants[2], 1.0/constants[3]); + computedConstants[27] = constants[1]/(constants[0] && constants[2]); + computedConstants[28] = constants[1] || constants[0]; + computedConstants[29] = constants[1] || constants[0] || constants[2]; + computedConstants[30] = (constants[1] < constants[0]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[1]+constants[0]) || (constants[2] > constants[3]); + computedConstants[32] = constants[1] || (constants[0] > constants[2]); + computedConstants[33] = (constants[1]-constants[0]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[1] || (constants[0] > constants[2]); + computedConstants[35] = pow(constants[1], constants[0]) || (constants[2] > constants[3]); + computedConstants[36] = pow(constants[1], 1.0/constants[0]) || (constants[2] > constants[3]); + computedConstants[37] = (constants[1] < constants[0]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[1] < constants[0]) || constants[2]; + computedConstants[39] = (constants[1] < constants[0]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[1] < constants[0]) || -constants[2]; + computedConstants[41] = (constants[1] < constants[0]) || pow(constants[2], constants[3]); + computedConstants[42] = (constants[1] < constants[0]) || pow(constants[2], 1.0/constants[3]); + computedConstants[43] = constants[1]/(constants[0] || constants[2]); + computedConstants[44] = xor(constants[1], constants[0]); + computedConstants[45] = xor(constants[1], xor(constants[0], constants[2])); + computedConstants[46] = xor(constants[1] < constants[0], constants[2] > constants[3]); + computedConstants[47] = xor(constants[1]+constants[0], constants[2] > constants[3]); + computedConstants[48] = xor(constants[1], constants[0] > constants[2]); + computedConstants[49] = xor(constants[1]-constants[0], constants[2] > constants[3]); + computedConstants[50] = xor(-constants[1], constants[0] > constants[2]); + computedConstants[51] = xor(pow(constants[1], constants[0]), constants[2] > constants[3]); + computedConstants[52] = xor(pow(constants[1], 1.0/constants[0]), constants[2] > constants[3]); + computedConstants[53] = xor(constants[1] < constants[0], constants[2]+constants[3]); + computedConstants[54] = xor(constants[1] < constants[0], constants[2]); + computedConstants[55] = xor(constants[1] < constants[0], constants[2]-constants[3]); + computedConstants[56] = xor(constants[1] < constants[0], -constants[2]); + computedConstants[57] = xor(constants[1] < constants[0], pow(constants[2], constants[3])); + computedConstants[58] = xor(constants[1] < constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[59] = constants[1]/xor(constants[0], constants[2]); + computedConstants[60] = !constants[1]; + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = (constants[1] < constants[0])+(constants[2] > constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = (constants[1] < constants[0])-(constants[2] > constants[3]); + computedConstants[66] = (constants[1] < constants[0])-(constants[2]+constants[3]); + computedConstants[67] = (constants[1] < constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -(constants[1] < constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = (constants[1] < constants[0])*(constants[2] > constants[3]); + computedConstants[75] = (constants[1]+constants[0])*(constants[2] > constants[3]); + computedConstants[76] = constants[1]*(constants[0] > constants[2]); + computedConstants[77] = (constants[1]-constants[0])*(constants[2] > constants[3]); + computedConstants[78] = -constants[1]*(constants[0] > constants[2]); + computedConstants[79] = (constants[1] < constants[0])*(constants[2]+constants[3]); + computedConstants[80] = (constants[1] < constants[0])*constants[2]; + computedConstants[81] = (constants[1] < constants[0])*(constants[2]-constants[3]); + computedConstants[82] = (constants[1] < constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = (constants[1] < constants[0])/(constants[3] > constants[2]); + computedConstants[85] = (constants[1]+constants[0])/(constants[3] > constants[2]); + computedConstants[86] = constants[1]/(constants[2] > constants[0]); + computedConstants[87] = (constants[1]-constants[0])/(constants[3] > constants[2]); + computedConstants[88] = -constants[1]/(constants[2] > constants[0]); + computedConstants[89] = (constants[1] < constants[0])/(constants[2]+constants[3]); + computedConstants[90] = (constants[1] < constants[0])/constants[2]; + computedConstants[91] = (constants[1] < constants[0])/(constants[2]-constants[3]); + computedConstants[92] = (constants[1] < constants[0])/-constants[2]; + computedConstants[93] = (constants[1] < constants[0])/(constants[2]*constants[3]); + computedConstants[94] = (constants[1] < constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = pow(constants[1], 2.0); + computedConstants[97] = pow(constants[1], 3.0); + computedConstants[98] = pow(constants[1], constants[0]); + computedConstants[99] = pow(constants[1] <= constants[0], constants[2] >= constants[3]); + computedConstants[100] = pow(constants[1]+constants[0], constants[2] >= constants[3]); + computedConstants[101] = pow(constants[1], constants[0] >= constants[2]); + computedConstants[102] = pow(constants[1]-constants[0], constants[2] >= constants[3]); + computedConstants[103] = pow(-constants[1], constants[0] >= constants[2]); + computedConstants[104] = pow(constants[1]*constants[0], constants[2] >= constants[3]); + computedConstants[105] = pow(constants[1]/constants[0], constants[2] >= constants[3]); + computedConstants[106] = pow(constants[1] <= constants[0], constants[2]+constants[3]); + computedConstants[107] = pow(constants[1] <= constants[0], constants[2]); + computedConstants[108] = pow(constants[1] <= constants[0], constants[2]-constants[3]); + computedConstants[109] = pow(constants[1] <= constants[0], -constants[2]); + computedConstants[110] = pow(constants[1] <= constants[0], constants[2]*constants[3]); + computedConstants[111] = pow(constants[1] <= constants[0], constants[2]/constants[3]); + computedConstants[112] = pow(constants[1] <= constants[0], pow(constants[2], constants[3])); + computedConstants[113] = pow(constants[1] <= constants[0], pow(constants[2], 1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = pow(constants[1], 1.0/3.0); + computedConstants[117] = pow(constants[1], 1.0/constants[0]); + computedConstants[118] = pow(constants[1] < constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[119] = pow(constants[1]+constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[120] = pow(constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[121] = pow(constants[1]-constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[122] = pow(-constants[1], 1.0/(constants[2] > constants[0])); + computedConstants[123] = pow(constants[1]*constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[124] = pow(constants[1]/constants[0], 1.0/(constants[3] > constants[2])); + computedConstants[125] = pow(constants[1] < constants[0], 1.0/(constants[2]+constants[3])); + computedConstants[126] = pow(constants[1] < constants[0], 1.0/constants[2]); + computedConstants[127] = pow(constants[1] < constants[0], 1.0/(constants[2]-constants[3])); + computedConstants[128] = pow(constants[1] < constants[0], 1.0/-constants[2]); + computedConstants[129] = pow(constants[1] < constants[0], 1.0/(constants[2]*constants[3])); + computedConstants[130] = pow(constants[1] < constants[0], 1.0/(constants[2]/constants[3])); + computedConstants[131] = pow(constants[1] < constants[0], 1.0/pow(constants[2], constants[3])); + computedConstants[132] = pow(constants[1] < constants[0], 1.0/pow(constants[2], 1.0/constants[3])); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = (constants[1] > constants[0])?constants[1]:NAN; + computedConstants[172] = (constants[1] > constants[0])?constants[1]:constants[2]; + computedConstants[173] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:NAN; + computedConstants[174] = (constants[1] > constants[0])?constants[1]:(constants[2] > constants[3])?constants[2]:(constants[4] > constants[5])?constants[4]:constants[6]; + computedConstants[175] = 123.0+((constants[1] > constants[0])?constants[1]:NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = (constants[1] && constants[0])+((constants[2] > constants[3])?constants[0]:NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[1] && constants[0])-(((constants[2] > constants[3])?constants[0]:NAN)-(constants[4]-((constants[2] > constants[3])?constants[0]:NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[1] && constants[0])*((constants[2] > constants[3])?constants[0]:NAN)*constants[4]*((constants[2] > constants[3])?constants[0]:NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[1] && constants[0])/(((constants[2] > constants[3])?constants[0]:NAN)/(constants[4]/((constants[2] > constants[3])?constants[0]:NAN))); + computedConstants[191] = (constants[1] || constants[0]) && xor(constants[1], constants[0]) && ((constants[2] > constants[3])?constants[0]:NAN) && constants[4] && ((constants[2] > constants[3])?constants[0]:NAN) && xor(constants[1], constants[0]) && (constants[1] || constants[0]); + computedConstants[192] = (constants[1] && constants[0]) || xor(constants[1], constants[0]) || ((constants[2] > constants[3])?constants[0]:NAN) || constants[4] || ((constants[2] > constants[3])?constants[0]:NAN) || xor(constants[1], constants[0]) || (constants[1] && constants[0]); + computedConstants[193] = xor(constants[1] && constants[0], xor(constants[1] || constants[0], xor((constants[2] > constants[3])?constants[0]:NAN, xor(xor(xor(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] || constants[0]), constants[1] && constants[0])))); + computedConstants[194] = pow(constants[1] && constants[0], pow((constants[2] > constants[3])?constants[0]:NAN, pow(pow(constants[4], (constants[2] > constants[3])?constants[0]:NAN), constants[1] && constants[0]))); + computedConstants[195] = pow(pow(pow(constants[1] && constants[0], 1.0/pow((constants[2] > constants[3])?constants[0]:NAN, 1.0/constants[4])), 1.0/((constants[2] > constants[3])?constants[0]:NAN)), 1.0/(constants[1] && constants[0])); + computedConstants[196] = -(constants[1] && constants[0])+-((constants[2] > constants[3])?constants[0]:NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 0be884d66..5ca831670 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -20,8 +20,8 @@ ] CONSTANT_INFO = [ - {"name": "m", "units": "dimensionless", "component": "my_component"}, {"name": "n", "units": "dimensionless", "component": "my_component"}, + {"name": "m", "units": "dimensionless", "component": "my_component"}, {"name": "o", "units": "dimensionless", "component": "my_component"}, {"name": "p", "units": "dimensionless", "component": "my_component"}, {"name": "q", "units": "dimensionless", "component": "my_component"}, @@ -227,13 +227,13 @@ {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component"}, {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component"}, {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component"}, - {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"}, - {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"} + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"} ] ALGEBRAIC_INFO = [ - {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component"}, - {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"} + {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component"} ] EXTERNAL_INFO = [ @@ -378,8 +378,8 @@ def objective_function_0(u, f, data): algebraic[0] = u[0] algebraic[1] = u[1] - f[0] = algebraic[0]+algebraic[1]+states[0]-0.0 - f[1] = algebraic[0]-algebraic[1]-(computed_constants[197]+computed_constants[198]) + f[0] = algebraic[1]+algebraic[0]+states[0]-0.0 + f[1] = algebraic[1]-algebraic[0]-(computed_constants[198]+computed_constants[197]) def find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals): @@ -396,8 +396,8 @@ def find_root_0(voi, states, rates, constants, computed_constants, algebraic, ex def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 - constants[0] = 1.0 - constants[1] = 2.0 + constants[0] = 2.0 + constants[1] = 1.0 constants[2] = 3.0 constants[3] = 4.0 constants[4] = 5.0 @@ -413,200 +413,200 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic computed_constants[184] = 3.14159265358979 computed_constants[185] = inf computed_constants[186] = nan - computed_constants[197] = 1.0 - computed_constants[198] = 3.0 - algebraic[0] = 1.0 - algebraic[1] = 2.0 + computed_constants[198] = 1.0 + computed_constants[197] = 3.0 + algebraic[0] = 2.0 + algebraic[1] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = eq_func(constants[0], constants[1]) - computed_constants[1] = constants[0]/eq_func(constants[1], constants[1]) - computed_constants[2] = neq_func(constants[0], constants[1]) - computed_constants[3] = constants[0]/neq_func(constants[1], constants[2]) - computed_constants[4] = lt_func(constants[0], constants[1]) - computed_constants[5] = constants[0]/lt_func(constants[1], constants[2]) - computed_constants[6] = leq_func(constants[0], constants[1]) - computed_constants[7] = constants[0]/leq_func(constants[1], constants[2]) - computed_constants[8] = gt_func(constants[0], constants[1]) - computed_constants[9] = constants[0]/gt_func(constants[1], constants[2]) - computed_constants[10] = geq_func(constants[0], constants[1]) - computed_constants[11] = constants[0]/geq_func(constants[1], constants[2]) - computed_constants[12] = and_func(constants[0], constants[1]) - computed_constants[13] = and_func(constants[0], and_func(constants[1], constants[2])) - computed_constants[14] = and_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[15] = and_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) - computed_constants[16] = and_func(constants[0], gt_func(constants[1], constants[2])) - computed_constants[17] = and_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) - computed_constants[18] = and_func(-constants[0], gt_func(constants[1], constants[2])) - computed_constants[19] = and_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[20] = and_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) - computed_constants[21] = and_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) - computed_constants[22] = and_func(lt_func(constants[0], constants[1]), constants[2]) - computed_constants[23] = and_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) - computed_constants[24] = and_func(lt_func(constants[0], constants[1]), -constants[2]) - computed_constants[25] = and_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) - computed_constants[26] = and_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) - computed_constants[27] = constants[0]/and_func(constants[1], constants[2]) - computed_constants[28] = or_func(constants[0], constants[1]) - computed_constants[29] = or_func(constants[0], or_func(constants[1], constants[2])) - computed_constants[30] = or_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[31] = or_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) - computed_constants[32] = or_func(constants[0], gt_func(constants[1], constants[2])) - computed_constants[33] = or_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) - computed_constants[34] = or_func(-constants[0], gt_func(constants[1], constants[2])) - computed_constants[35] = or_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[36] = or_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) - computed_constants[37] = or_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) - computed_constants[38] = or_func(lt_func(constants[0], constants[1]), constants[2]) - computed_constants[39] = or_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) - computed_constants[40] = or_func(lt_func(constants[0], constants[1]), -constants[2]) - computed_constants[41] = or_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) - computed_constants[42] = or_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) - computed_constants[43] = constants[0]/or_func(constants[1], constants[2]) - computed_constants[44] = xor_func(constants[0], constants[1]) - computed_constants[45] = xor_func(constants[0], xor_func(constants[1], constants[2])) - computed_constants[46] = xor_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[47] = xor_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) - computed_constants[48] = xor_func(constants[0], gt_func(constants[1], constants[2])) - computed_constants[49] = xor_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) - computed_constants[50] = xor_func(-constants[0], gt_func(constants[1], constants[2])) - computed_constants[51] = xor_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[52] = xor_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) - computed_constants[53] = xor_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) - computed_constants[54] = xor_func(lt_func(constants[0], constants[1]), constants[2]) - computed_constants[55] = xor_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) - computed_constants[56] = xor_func(lt_func(constants[0], constants[1]), -constants[2]) - computed_constants[57] = xor_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) - computed_constants[58] = xor_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) - computed_constants[59] = constants[0]/xor_func(constants[1], constants[2]) - computed_constants[60] = not_func(constants[0]) - computed_constants[61] = constants[0]+constants[1]+constants[2] - computed_constants[62] = lt_func(constants[0], constants[1])+gt_func(constants[2], constants[3]) - computed_constants[63] = constants[0] - computed_constants[64] = constants[0]-constants[1] - computed_constants[65] = lt_func(constants[0], constants[1])-gt_func(constants[2], constants[3]) - computed_constants[66] = lt_func(constants[0], constants[1])-(constants[2]+constants[3]) - computed_constants[67] = lt_func(constants[0], constants[1])-constants[2] - computed_constants[68] = constants[0]-(-constants[1]) - computed_constants[69] = constants[0]-(-constants[1]*constants[2]) - computed_constants[70] = -constants[0] - computed_constants[71] = -lt_func(constants[0], constants[1]) - computed_constants[72] = constants[0]*constants[1] - computed_constants[73] = constants[0]*constants[1]*constants[2] - computed_constants[74] = lt_func(constants[0], constants[1])*gt_func(constants[2], constants[3]) - computed_constants[75] = (constants[0]+constants[1])*gt_func(constants[2], constants[3]) - computed_constants[76] = constants[0]*gt_func(constants[1], constants[2]) - computed_constants[77] = (constants[0]-constants[1])*gt_func(constants[2], constants[3]) - computed_constants[78] = -constants[0]*gt_func(constants[1], constants[2]) - computed_constants[79] = lt_func(constants[0], constants[1])*(constants[2]+constants[3]) - computed_constants[80] = lt_func(constants[0], constants[1])*constants[2] - computed_constants[81] = lt_func(constants[0], constants[1])*(constants[2]-constants[3]) - computed_constants[82] = lt_func(constants[0], constants[1])*-constants[2] - computed_constants[83] = constants[0]/constants[1] - computed_constants[84] = lt_func(constants[0], constants[1])/gt_func(constants[3], constants[2]) - computed_constants[85] = (constants[0]+constants[1])/gt_func(constants[3], constants[2]) - computed_constants[86] = constants[0]/gt_func(constants[2], constants[1]) - computed_constants[87] = (constants[0]-constants[1])/gt_func(constants[3], constants[2]) - computed_constants[88] = -constants[0]/gt_func(constants[2], constants[1]) - computed_constants[89] = lt_func(constants[0], constants[1])/(constants[2]+constants[3]) - computed_constants[90] = lt_func(constants[0], constants[1])/constants[2] - computed_constants[91] = lt_func(constants[0], constants[1])/(constants[2]-constants[3]) - computed_constants[92] = lt_func(constants[0], constants[1])/-constants[2] - computed_constants[93] = lt_func(constants[0], constants[1])/(constants[2]*constants[3]) - computed_constants[94] = lt_func(constants[0], constants[1])/(constants[2]/constants[3]) - computed_constants[95] = sqrt(constants[0]) - computed_constants[96] = pow(constants[0], 2.0) - computed_constants[97] = pow(constants[0], 3.0) - computed_constants[98] = pow(constants[0], constants[1]) - computed_constants[99] = pow(leq_func(constants[0], constants[1]), geq_func(constants[2], constants[3])) - computed_constants[100] = pow(constants[0]+constants[1], geq_func(constants[2], constants[3])) - computed_constants[101] = pow(constants[0], geq_func(constants[1], constants[2])) - computed_constants[102] = pow(constants[0]-constants[1], geq_func(constants[2], constants[3])) - computed_constants[103] = pow(-constants[0], geq_func(constants[1], constants[2])) - computed_constants[104] = pow(constants[0]*constants[1], geq_func(constants[2], constants[3])) - computed_constants[105] = pow(constants[0]/constants[1], geq_func(constants[2], constants[3])) - computed_constants[106] = pow(leq_func(constants[0], constants[1]), constants[2]+constants[3]) - computed_constants[107] = pow(leq_func(constants[0], constants[1]), constants[2]) - computed_constants[108] = pow(leq_func(constants[0], constants[1]), constants[2]-constants[3]) - computed_constants[109] = pow(leq_func(constants[0], constants[1]), -constants[2]) - computed_constants[110] = pow(leq_func(constants[0], constants[1]), constants[2]*constants[3]) - computed_constants[111] = pow(leq_func(constants[0], constants[1]), constants[2]/constants[3]) - computed_constants[112] = pow(leq_func(constants[0], constants[1]), pow(constants[2], constants[3])) - computed_constants[113] = pow(leq_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) - computed_constants[114] = sqrt(constants[0]) - computed_constants[115] = sqrt(constants[0]) - computed_constants[116] = pow(constants[0], 1.0/3.0) - computed_constants[117] = pow(constants[0], 1.0/constants[1]) - computed_constants[118] = pow(lt_func(constants[0], constants[1]), 1.0/gt_func(constants[3], constants[2])) - computed_constants[119] = pow(constants[0]+constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[120] = pow(constants[0], 1.0/gt_func(constants[2], constants[1])) - computed_constants[121] = pow(constants[0]-constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[122] = pow(-constants[0], 1.0/gt_func(constants[2], constants[1])) - computed_constants[123] = pow(constants[0]*constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[124] = pow(constants[0]/constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[125] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]+constants[3])) - computed_constants[126] = pow(lt_func(constants[0], constants[1]), 1.0/constants[2]) - computed_constants[127] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]-constants[3])) - computed_constants[128] = pow(lt_func(constants[0], constants[1]), 1.0/-constants[2]) - computed_constants[129] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]*constants[3])) - computed_constants[130] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]/constants[3])) - computed_constants[131] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])) - computed_constants[132] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])) - computed_constants[133] = fabs(constants[0]) - computed_constants[134] = exp(constants[0]) - computed_constants[135] = log(constants[0]) - computed_constants[136] = log10(constants[0]) - computed_constants[137] = log(constants[0])/log(2.0) - computed_constants[138] = log10(constants[0]) - computed_constants[139] = log(constants[0])/log(constants[1]) - computed_constants[140] = ceil(constants[0]) - computed_constants[141] = floor(constants[0]) - computed_constants[142] = min(constants[0], constants[1]) - computed_constants[143] = min(constants[0], min(constants[1], constants[2])) - computed_constants[144] = max(constants[0], constants[1]) - computed_constants[145] = max(constants[0], max(constants[1], constants[2])) - computed_constants[146] = fmod(constants[0], constants[1]) - computed_constants[147] = sin(constants[0]) - computed_constants[148] = cos(constants[0]) - computed_constants[149] = tan(constants[0]) - computed_constants[150] = sec(constants[0]) - computed_constants[151] = csc(constants[0]) - computed_constants[152] = cot(constants[0]) - computed_constants[153] = sinh(constants[0]) - computed_constants[154] = cosh(constants[0]) - computed_constants[155] = tanh(constants[0]) - computed_constants[156] = sech(constants[0]) - computed_constants[157] = csch(constants[0]) - computed_constants[158] = coth(constants[0]) - computed_constants[159] = asin(constants[0]) - computed_constants[160] = acos(constants[0]) - computed_constants[161] = atan(constants[0]) - computed_constants[162] = asec(constants[0]) - computed_constants[163] = acsc(constants[0]) - computed_constants[164] = acot(constants[0]) - computed_constants[165] = asinh(constants[0]) - computed_constants[166] = acosh(constants[0]) - computed_constants[167] = atanh(constants[0]/2.0) - computed_constants[168] = asech(constants[0]) - computed_constants[169] = acsch(constants[0]) - computed_constants[170] = acoth(2.0*constants[0]) - computed_constants[171] = constants[0] if gt_func(constants[0], constants[1]) else nan - computed_constants[172] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] - computed_constants[173] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan - computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] - computed_constants[175] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) - computed_constants[180] = constants[0] - computed_constants[187] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) - computed_constants[188] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) - computed_constants[189] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) - computed_constants[190] = and_func(constants[0], constants[1])/((constants[1] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[1] if gt_func(constants[2], constants[3]) else nan))) - computed_constants[191] = and_func(or_func(constants[0], constants[1]), and_func(xor_func(constants[0], constants[1]), and_func(constants[1] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), or_func(constants[0], constants[1]))))) - computed_constants[192] = or_func(and_func(constants[0], constants[1]), or_func(xor_func(constants[0], constants[1]), or_func(constants[1] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) - computed_constants[193] = xor_func(and_func(constants[0], constants[1]), xor_func(or_func(constants[0], constants[1]), xor_func(constants[1] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), or_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) - computed_constants[194] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) - computed_constants[195] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) - computed_constants[196] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) + computed_constants[0] = eq_func(constants[1], constants[0]) + computed_constants[1] = constants[1]/eq_func(constants[0], constants[0]) + computed_constants[2] = neq_func(constants[1], constants[0]) + computed_constants[3] = constants[1]/neq_func(constants[0], constants[2]) + computed_constants[4] = lt_func(constants[1], constants[0]) + computed_constants[5] = constants[1]/lt_func(constants[0], constants[2]) + computed_constants[6] = leq_func(constants[1], constants[0]) + computed_constants[7] = constants[1]/leq_func(constants[0], constants[2]) + computed_constants[8] = gt_func(constants[1], constants[0]) + computed_constants[9] = constants[1]/gt_func(constants[0], constants[2]) + computed_constants[10] = geq_func(constants[1], constants[0]) + computed_constants[11] = constants[1]/geq_func(constants[0], constants[2]) + computed_constants[12] = and_func(constants[1], constants[0]) + computed_constants[13] = and_func(constants[1], and_func(constants[0], constants[2])) + computed_constants[14] = and_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[15] = and_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[16] = and_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[17] = and_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[18] = and_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[19] = and_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[20] = and_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[21] = and_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[22] = and_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[23] = and_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[24] = and_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[25] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[26] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[27] = constants[1]/and_func(constants[0], constants[2]) + computed_constants[28] = or_func(constants[1], constants[0]) + computed_constants[29] = or_func(constants[1], or_func(constants[0], constants[2])) + computed_constants[30] = or_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[31] = or_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[32] = or_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[33] = or_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[34] = or_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[35] = or_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[36] = or_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[37] = or_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[38] = or_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[39] = or_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[40] = or_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[41] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[42] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[43] = constants[1]/or_func(constants[0], constants[2]) + computed_constants[44] = xor_func(constants[1], constants[0]) + computed_constants[45] = xor_func(constants[1], xor_func(constants[0], constants[2])) + computed_constants[46] = xor_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[47] = xor_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[48] = xor_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[49] = xor_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[50] = xor_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[51] = xor_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[52] = xor_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[53] = xor_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[54] = xor_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[55] = xor_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[56] = xor_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[57] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[58] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[59] = constants[1]/xor_func(constants[0], constants[2]) + computed_constants[60] = not_func(constants[1]) + computed_constants[61] = constants[1]+constants[0]+constants[2] + computed_constants[62] = lt_func(constants[1], constants[0])+gt_func(constants[2], constants[3]) + computed_constants[63] = constants[1] + computed_constants[64] = constants[1]-constants[0] + computed_constants[65] = lt_func(constants[1], constants[0])-gt_func(constants[2], constants[3]) + computed_constants[66] = lt_func(constants[1], constants[0])-(constants[2]+constants[3]) + computed_constants[67] = lt_func(constants[1], constants[0])-constants[2] + computed_constants[68] = constants[1]-(-constants[0]) + computed_constants[69] = constants[1]-(-constants[0]*constants[2]) + computed_constants[70] = -constants[1] + computed_constants[71] = -lt_func(constants[1], constants[0]) + computed_constants[72] = constants[1]*constants[0] + computed_constants[73] = constants[1]*constants[0]*constants[2] + computed_constants[74] = lt_func(constants[1], constants[0])*gt_func(constants[2], constants[3]) + computed_constants[75] = (constants[1]+constants[0])*gt_func(constants[2], constants[3]) + computed_constants[76] = constants[1]*gt_func(constants[0], constants[2]) + computed_constants[77] = (constants[1]-constants[0])*gt_func(constants[2], constants[3]) + computed_constants[78] = -constants[1]*gt_func(constants[0], constants[2]) + computed_constants[79] = lt_func(constants[1], constants[0])*(constants[2]+constants[3]) + computed_constants[80] = lt_func(constants[1], constants[0])*constants[2] + computed_constants[81] = lt_func(constants[1], constants[0])*(constants[2]-constants[3]) + computed_constants[82] = lt_func(constants[1], constants[0])*-constants[2] + computed_constants[83] = constants[1]/constants[0] + computed_constants[84] = lt_func(constants[1], constants[0])/gt_func(constants[3], constants[2]) + computed_constants[85] = (constants[1]+constants[0])/gt_func(constants[3], constants[2]) + computed_constants[86] = constants[1]/gt_func(constants[2], constants[0]) + computed_constants[87] = (constants[1]-constants[0])/gt_func(constants[3], constants[2]) + computed_constants[88] = -constants[1]/gt_func(constants[2], constants[0]) + computed_constants[89] = lt_func(constants[1], constants[0])/(constants[2]+constants[3]) + computed_constants[90] = lt_func(constants[1], constants[0])/constants[2] + computed_constants[91] = lt_func(constants[1], constants[0])/(constants[2]-constants[3]) + computed_constants[92] = lt_func(constants[1], constants[0])/-constants[2] + computed_constants[93] = lt_func(constants[1], constants[0])/(constants[2]*constants[3]) + computed_constants[94] = lt_func(constants[1], constants[0])/(constants[2]/constants[3]) + computed_constants[95] = sqrt(constants[1]) + computed_constants[96] = pow(constants[1], 2.0) + computed_constants[97] = pow(constants[1], 3.0) + computed_constants[98] = pow(constants[1], constants[0]) + computed_constants[99] = pow(leq_func(constants[1], constants[0]), geq_func(constants[2], constants[3])) + computed_constants[100] = pow(constants[1]+constants[0], geq_func(constants[2], constants[3])) + computed_constants[101] = pow(constants[1], geq_func(constants[0], constants[2])) + computed_constants[102] = pow(constants[1]-constants[0], geq_func(constants[2], constants[3])) + computed_constants[103] = pow(-constants[1], geq_func(constants[0], constants[2])) + computed_constants[104] = pow(constants[1]*constants[0], geq_func(constants[2], constants[3])) + computed_constants[105] = pow(constants[1]/constants[0], geq_func(constants[2], constants[3])) + computed_constants[106] = pow(leq_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[107] = pow(leq_func(constants[1], constants[0]), constants[2]) + computed_constants[108] = pow(leq_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[109] = pow(leq_func(constants[1], constants[0]), -constants[2]) + computed_constants[110] = pow(leq_func(constants[1], constants[0]), constants[2]*constants[3]) + computed_constants[111] = pow(leq_func(constants[1], constants[0]), constants[2]/constants[3]) + computed_constants[112] = pow(leq_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[113] = pow(leq_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[114] = sqrt(constants[1]) + computed_constants[115] = sqrt(constants[1]) + computed_constants[116] = pow(constants[1], 1.0/3.0) + computed_constants[117] = pow(constants[1], 1.0/constants[0]) + computed_constants[118] = pow(lt_func(constants[1], constants[0]), 1.0/gt_func(constants[3], constants[2])) + computed_constants[119] = pow(constants[1]+constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[120] = pow(constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[121] = pow(constants[1]-constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[122] = pow(-constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[123] = pow(constants[1]*constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[124] = pow(constants[1]/constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[125] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]+constants[3])) + computed_constants[126] = pow(lt_func(constants[1], constants[0]), 1.0/constants[2]) + computed_constants[127] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]-constants[3])) + computed_constants[128] = pow(lt_func(constants[1], constants[0]), 1.0/-constants[2]) + computed_constants[129] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]*constants[3])) + computed_constants[130] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]/constants[3])) + computed_constants[131] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], constants[3])) + computed_constants[132] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], 1.0/constants[3])) + computed_constants[133] = fabs(constants[1]) + computed_constants[134] = exp(constants[1]) + computed_constants[135] = log(constants[1]) + computed_constants[136] = log10(constants[1]) + computed_constants[137] = log(constants[1])/log(2.0) + computed_constants[138] = log10(constants[1]) + computed_constants[139] = log(constants[1])/log(constants[0]) + computed_constants[140] = ceil(constants[1]) + computed_constants[141] = floor(constants[1]) + computed_constants[142] = min(constants[1], constants[0]) + computed_constants[143] = min(constants[1], min(constants[0], constants[2])) + computed_constants[144] = max(constants[1], constants[0]) + computed_constants[145] = max(constants[1], max(constants[0], constants[2])) + computed_constants[146] = fmod(constants[1], constants[0]) + computed_constants[147] = sin(constants[1]) + computed_constants[148] = cos(constants[1]) + computed_constants[149] = tan(constants[1]) + computed_constants[150] = sec(constants[1]) + computed_constants[151] = csc(constants[1]) + computed_constants[152] = cot(constants[1]) + computed_constants[153] = sinh(constants[1]) + computed_constants[154] = cosh(constants[1]) + computed_constants[155] = tanh(constants[1]) + computed_constants[156] = sech(constants[1]) + computed_constants[157] = csch(constants[1]) + computed_constants[158] = coth(constants[1]) + computed_constants[159] = asin(constants[1]) + computed_constants[160] = acos(constants[1]) + computed_constants[161] = atan(constants[1]) + computed_constants[162] = asec(constants[1]) + computed_constants[163] = acsc(constants[1]) + computed_constants[164] = acot(constants[1]) + computed_constants[165] = asinh(constants[1]) + computed_constants[166] = acosh(constants[1]) + computed_constants[167] = atanh(constants[1]/2.0) + computed_constants[168] = asech(constants[1]) + computed_constants[169] = acsch(constants[1]) + computed_constants[170] = acoth(2.0*constants[1]) + computed_constants[171] = constants[1] if gt_func(constants[1], constants[0]) else nan + computed_constants[172] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] + computed_constants[173] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan + computed_constants[174] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] + computed_constants[175] = 123.0+(constants[1] if gt_func(constants[1], constants[0]) else nan) + computed_constants[180] = constants[1] + computed_constants[187] = and_func(constants[1], constants[0])+(constants[0] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) + computed_constants[188] = and_func(constants[1], constants[0])-((constants[0] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[0] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) + computed_constants[189] = and_func(constants[1], constants[0])*(constants[0] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[0] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) + computed_constants[190] = and_func(constants[1], constants[0])/((constants[0] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[0] if gt_func(constants[2], constants[3]) else nan))) + computed_constants[191] = and_func(or_func(constants[1], constants[0]), and_func(xor_func(constants[1], constants[0]), and_func(constants[0] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), or_func(constants[1], constants[0]))))) + computed_constants[192] = or_func(and_func(constants[1], constants[0]), or_func(xor_func(constants[1], constants[0]), or_func(constants[0] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[193] = xor_func(and_func(constants[1], constants[0]), xor_func(or_func(constants[1], constants[0]), xor_func(constants[0] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), or_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[194] = pow(and_func(constants[1], constants[0]), pow(constants[0] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), and_func(constants[1], constants[0])))) + computed_constants[195] = pow(pow(pow(and_func(constants[1], constants[0]), 1.0/pow(constants[0] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[0] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[1], constants[0])) + computed_constants[196] = -and_func(constants[1], constants[0])+-(constants[0] if gt_func(constants[2], constants[3]) else nan) def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index 8b148ed66..6cd0aa81b 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -104,8 +104,8 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[0] = u[0]; algebraic[1] = u[1]; - f[0] = algebraic[0]+algebraic[1]+states[0]-0.0; - f[1] = algebraic[0]-algebraic[1]-(computedConstants[197]+computedConstants[198]); + f[0] = algebraic[1]+algebraic[0]+states[0]-0.0; + f[1] = algebraic[1]-algebraic[0]-(computedConstants[198]+computedConstants[197]); } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) @@ -124,193 +124,193 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = constants[0] == constants[1]; - computedConstants[1] = constants[0]/(constants[1] == constants[1]); - computedConstants[2] = constants[0] != constants[1]; - computedConstants[3] = constants[0]/(constants[1] != constants[2]); - computedConstants[4] = constants[0] < constants[1]; - computedConstants[5] = constants[0]/(constants[1] < constants[2]); - computedConstants[6] = constants[0] <= constants[1]; - computedConstants[7] = constants[0]/(constants[1] <= constants[2]); - computedConstants[8] = constants[0] > constants[1]; - computedConstants[9] = constants[0]/(constants[1] > constants[2]); - computedConstants[10] = constants[0] >= constants[1]; - computedConstants[11] = constants[0]/(constants[1] >= constants[2]); - computedConstants[12] = constants[0] && constants[1]; - computedConstants[13] = constants[0] && constants[1] && constants[2]; - computedConstants[14] = (constants[0] < constants[1]) && (constants[2] > constants[3]); - computedConstants[15] = (constants[0]+constants[1]) && (constants[2] > constants[3]); - computedConstants[16] = constants[0] && (constants[1] > constants[2]); - computedConstants[17] = (constants[0]-constants[1]) && (constants[2] > constants[3]); - computedConstants[18] = -constants[0] && (constants[1] > constants[2]); - computedConstants[19] = (constants[0]^^constants[1]) && (constants[2] > constants[3]); - computedConstants[20] = (constants[0]^^(1.0/constants[1])) && (constants[2] > constants[3]); - computedConstants[21] = (constants[0] < constants[1]) && (constants[2]+constants[3]); - computedConstants[22] = (constants[0] < constants[1]) && constants[2]; - computedConstants[23] = (constants[0] < constants[1]) && (constants[2]-constants[3]); - computedConstants[24] = (constants[0] < constants[1]) && -constants[2]; - computedConstants[25] = (constants[0] < constants[1]) && (constants[2]^^constants[3]); - computedConstants[26] = (constants[0] < constants[1]) && (constants[2]^^(1.0/constants[3])); - computedConstants[27] = constants[0]/(constants[1] && constants[2]); - computedConstants[28] = constants[0] || constants[1]; - computedConstants[29] = constants[0] || constants[1] || constants[2]; - computedConstants[30] = (constants[0] < constants[1]) || (constants[2] > constants[3]); - computedConstants[31] = (constants[0]+constants[1]) || (constants[2] > constants[3]); - computedConstants[32] = constants[0] || (constants[1] > constants[2]); - computedConstants[33] = (constants[0]-constants[1]) || (constants[2] > constants[3]); - computedConstants[34] = -constants[0] || (constants[1] > constants[2]); - computedConstants[35] = (constants[0]^^constants[1]) || (constants[2] > constants[3]); - computedConstants[36] = (constants[0]^^(1.0/constants[1])) || (constants[2] > constants[3]); - computedConstants[37] = (constants[0] < constants[1]) || (constants[2]+constants[3]); - computedConstants[38] = (constants[0] < constants[1]) || constants[2]; - computedConstants[39] = (constants[0] < constants[1]) || (constants[2]-constants[3]); - computedConstants[40] = (constants[0] < constants[1]) || -constants[2]; - computedConstants[41] = (constants[0] < constants[1]) || (constants[2]^^constants[3]); - computedConstants[42] = (constants[0] < constants[1]) || (constants[2]^^(1.0/constants[3])); - computedConstants[43] = constants[0]/(constants[1] || constants[2]); - computedConstants[44] = constants[0]^constants[1]; - computedConstants[45] = constants[0]^constants[1]^constants[2]; - computedConstants[46] = (constants[0] < constants[1])^(constants[2] > constants[3]); - computedConstants[47] = (constants[0]+constants[1])^(constants[2] > constants[3]); - computedConstants[48] = constants[0]^(constants[1] > constants[2]); - computedConstants[49] = (constants[0]-constants[1])^(constants[2] > constants[3]); - computedConstants[50] = -constants[0]^(constants[1] > constants[2]); - computedConstants[51] = (constants[0]^^constants[1])^(constants[2] > constants[3]); - computedConstants[52] = (constants[0]^^(1.0/constants[1]))^(constants[2] > constants[3]); - computedConstants[53] = (constants[0] < constants[1])^(constants[2]+constants[3]); - computedConstants[54] = (constants[0] < constants[1])^constants[2]; - computedConstants[55] = (constants[0] < constants[1])^(constants[2]-constants[3]); - computedConstants[56] = (constants[0] < constants[1])^-constants[2]; - computedConstants[57] = (constants[0] < constants[1])^(constants[2]^^constants[3]); - computedConstants[58] = (constants[0] < constants[1])^(constants[2]^^(1.0/constants[3])); - computedConstants[59] = constants[0]/(constants[1]^constants[2]); - computedConstants[60] = !constants[0]; - computedConstants[61] = constants[0]+constants[1]+constants[2]; - computedConstants[62] = (constants[0] < constants[1])+(constants[2] > constants[3]); - computedConstants[63] = constants[0]; - computedConstants[64] = constants[0]-constants[1]; - computedConstants[65] = (constants[0] < constants[1])-(constants[2] > constants[3]); - computedConstants[66] = (constants[0] < constants[1])-(constants[2]+constants[3]); - computedConstants[67] = (constants[0] < constants[1])-constants[2]; - computedConstants[68] = constants[0]-(-constants[1]); - computedConstants[69] = constants[0]-(-constants[1]*constants[2]); - computedConstants[70] = -constants[0]; - computedConstants[71] = -(constants[0] < constants[1]); - computedConstants[72] = constants[0]*constants[1]; - computedConstants[73] = constants[0]*constants[1]*constants[2]; - computedConstants[74] = (constants[0] < constants[1])*(constants[2] > constants[3]); - computedConstants[75] = (constants[0]+constants[1])*(constants[2] > constants[3]); - computedConstants[76] = constants[0]*(constants[1] > constants[2]); - computedConstants[77] = (constants[0]-constants[1])*(constants[2] > constants[3]); - computedConstants[78] = -constants[0]*(constants[1] > constants[2]); - computedConstants[79] = (constants[0] < constants[1])*(constants[2]+constants[3]); - computedConstants[80] = (constants[0] < constants[1])*constants[2]; - computedConstants[81] = (constants[0] < constants[1])*(constants[2]-constants[3]); - computedConstants[82] = (constants[0] < constants[1])*-constants[2]; - computedConstants[83] = constants[0]/constants[1]; - computedConstants[84] = (constants[0] < constants[1])/(constants[3] > constants[2]); - computedConstants[85] = (constants[0]+constants[1])/(constants[3] > constants[2]); - computedConstants[86] = constants[0]/(constants[2] > constants[1]); - computedConstants[87] = (constants[0]-constants[1])/(constants[3] > constants[2]); - computedConstants[88] = -constants[0]/(constants[2] > constants[1]); - computedConstants[89] = (constants[0] < constants[1])/(constants[2]+constants[3]); - computedConstants[90] = (constants[0] < constants[1])/constants[2]; - computedConstants[91] = (constants[0] < constants[1])/(constants[2]-constants[3]); - computedConstants[92] = (constants[0] < constants[1])/-constants[2]; - computedConstants[93] = (constants[0] < constants[1])/(constants[2]*constants[3]); - computedConstants[94] = (constants[0] < constants[1])/(constants[2]/constants[3]); - computedConstants[95] = sqrt(constants[0]); - computedConstants[96] = sqr(constants[0]); - computedConstants[97] = constants[0]^^3.0; - computedConstants[98] = constants[0]^^constants[1]; - computedConstants[99] = (constants[0] <= constants[1])^^(constants[2] >= constants[3]); - computedConstants[100] = (constants[0]+constants[1])^^(constants[2] >= constants[3]); - computedConstants[101] = constants[0]^^(constants[1] >= constants[2]); - computedConstants[102] = (constants[0]-constants[1])^^(constants[2] >= constants[3]); - computedConstants[103] = (-constants[0])^^(constants[1] >= constants[2]); - computedConstants[104] = (constants[0]*constants[1])^^(constants[2] >= constants[3]); - computedConstants[105] = (constants[0]/constants[1])^^(constants[2] >= constants[3]); - computedConstants[106] = (constants[0] <= constants[1])^^(constants[2]+constants[3]); - computedConstants[107] = (constants[0] <= constants[1])^^constants[2]; - computedConstants[108] = (constants[0] <= constants[1])^^constants[2]-constants[3]; - computedConstants[109] = (constants[0] <= constants[1])^^-constants[2]; - computedConstants[110] = (constants[0] <= constants[1])^^(constants[2]*constants[3]); - computedConstants[111] = (constants[0] <= constants[1])^^(constants[2]/constants[3]); - computedConstants[112] = (constants[0] <= constants[1])^^(constants[2]^^constants[3]); - computedConstants[113] = (constants[0] <= constants[1])^^(constants[2]^^(1.0/constants[3])); - computedConstants[114] = sqrt(constants[0]); - computedConstants[115] = sqrt(constants[0]); - computedConstants[116] = constants[0]^^(1.0/3.0); - computedConstants[117] = constants[0]^^(1.0/constants[1]); - computedConstants[118] = (constants[0] < constants[1])^^(1.0/(constants[3] > constants[2])); - computedConstants[119] = (constants[0]+constants[1])^^(1.0/(constants[3] > constants[2])); - computedConstants[120] = constants[0]^^(1.0/(constants[2] > constants[1])); - computedConstants[121] = (constants[0]-constants[1])^^(1.0/(constants[3] > constants[2])); - computedConstants[122] = (-constants[0])^^(1.0/(constants[2] > constants[1])); - computedConstants[123] = (constants[0]*constants[1])^^(1.0/(constants[3] > constants[2])); - computedConstants[124] = (constants[0]/constants[1])^^(1.0/(constants[3] > constants[2])); - computedConstants[125] = (constants[0] < constants[1])^^(1.0/(constants[2]+constants[3])); - computedConstants[126] = (constants[0] < constants[1])^^(1.0/constants[2]); - computedConstants[127] = (constants[0] < constants[1])^^(1.0/(constants[2]-constants[3])); - computedConstants[128] = (constants[0] < constants[1])^^(1.0/(-constants[2])); - computedConstants[129] = (constants[0] < constants[1])^^(1.0/(constants[2]*constants[3])); - computedConstants[130] = (constants[0] < constants[1])^^(1.0/(constants[2]/constants[3])); - computedConstants[131] = (constants[0] < constants[1])^^(1.0/(constants[2]^^constants[3])); - computedConstants[132] = (constants[0] < constants[1])^^(1.0/(constants[2]^^(1.0/constants[3]))); - computedConstants[133] = fabs(constants[0]); - computedConstants[134] = exp(constants[0]); - computedConstants[135] = log(constants[0]); - computedConstants[136] = log10(constants[0]); - computedConstants[137] = log(constants[0])/log(2.0); - computedConstants[138] = log10(constants[0]); - computedConstants[139] = log(constants[0])/log(constants[1]); - computedConstants[140] = ceil(constants[0]); - computedConstants[141] = floor(constants[0]); - computedConstants[142] = min(constants[0], constants[1]); - computedConstants[143] = min(constants[0], min(constants[1], constants[2])); - computedConstants[144] = max(constants[0], constants[1]); - computedConstants[145] = max(constants[0], max(constants[1], constants[2])); - computedConstants[146] = fmod(constants[0], constants[1]); - computedConstants[147] = sin(constants[0]); - computedConstants[148] = cos(constants[0]); - computedConstants[149] = tan(constants[0]); - computedConstants[150] = sec(constants[0]); - computedConstants[151] = csc(constants[0]); - computedConstants[152] = cot(constants[0]); - computedConstants[153] = sinh(constants[0]); - computedConstants[154] = cosh(constants[0]); - computedConstants[155] = tanh(constants[0]); - computedConstants[156] = sech(constants[0]); - computedConstants[157] = csch(constants[0]); - computedConstants[158] = coth(constants[0]); - computedConstants[159] = asin(constants[0]); - computedConstants[160] = acos(constants[0]); - computedConstants[161] = atan(constants[0]); - computedConstants[162] = asec(constants[0]); - computedConstants[163] = acsc(constants[0]); - computedConstants[164] = acot(constants[0]); - computedConstants[165] = asinh(constants[0]); - computedConstants[166] = acosh(constants[0]); - computedConstants[167] = atanh(constants[0]/2.0); - computedConstants[168] = asech(constants[0]); - computedConstants[169] = acsch(constants[0]); - computedConstants[170] = acoth(2.0*constants[0]); - computedConstants[171] = piecewise(constants[0] > constants[1], constants[0], NAN); - computedConstants[172] = piecewise(constants[0] > constants[1], constants[0], constants[2]); - computedConstants[173] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], NAN))); - computedConstants[174] = piecewise(constants[0] > constants[1], constants[0], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], constants[6]))); - computedConstants[175] = 123.0+piecewise(constants[0] > constants[1], constants[0], NAN); - computedConstants[180] = constants[0]; - computedConstants[187] = (constants[0] && constants[1])+piecewise(constants[2] > constants[3], constants[1], NAN)+constants[4]+(constants[5] && constants[6]); - computedConstants[188] = (constants[0] && constants[1])-(piecewise(constants[2] > constants[3], constants[1], NAN)-(constants[4]-piecewise(constants[2] > constants[3], constants[1], NAN)))-(constants[5] && constants[6]); - computedConstants[189] = (constants[0] && constants[1])*piecewise(constants[2] > constants[3], constants[1], NAN)*constants[4]*piecewise(constants[2] > constants[3], constants[1], NAN)*(constants[5] && constants[6]); - computedConstants[190] = (constants[0] && constants[1])/(piecewise(constants[2] > constants[3], constants[1], NAN)/(constants[4]/piecewise(constants[2] > constants[3], constants[1], NAN))); - computedConstants[191] = (constants[0] || constants[1]) && (constants[0]^constants[1]) && piecewise(constants[2] > constants[3], constants[1], NAN) && constants[4] && piecewise(constants[2] > constants[3], constants[1], NAN) && (constants[0]^constants[1]) && (constants[0] || constants[1]); - computedConstants[192] = (constants[0] && constants[1]) || (constants[0]^constants[1]) || piecewise(constants[2] > constants[3], constants[1], NAN) || constants[4] || piecewise(constants[2] > constants[3], constants[1], NAN) || (constants[0]^constants[1]) || (constants[0] && constants[1]); - computedConstants[193] = (constants[0] && constants[1])^(constants[0] || constants[1])^piecewise(constants[2] > constants[3], constants[1], NAN)^constants[4]^piecewise(constants[2] > constants[3], constants[1], NAN)^(constants[0] || constants[1])^(constants[0] && constants[1]); - computedConstants[194] = (constants[0] && constants[1])^^(piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[4]^^piecewise(constants[2] > constants[3], constants[1], NAN)^^(constants[0] && constants[1]))); - computedConstants[195] = (constants[0] && constants[1])^^(1.0/(piecewise(constants[2] > constants[3], constants[1], NAN)^^(1.0/constants[4])))^^(1.0/piecewise(constants[2] > constants[3], constants[1], NAN))^^(1.0/(constants[0] && constants[1])); - computedConstants[196] = -(constants[0] && constants[1])+-piecewise(constants[2] > constants[3], constants[1], NAN); + computedConstants[0] = constants[1] == constants[0]; + computedConstants[1] = constants[1]/(constants[0] == constants[0]); + computedConstants[2] = constants[1] != constants[0]; + computedConstants[3] = constants[1]/(constants[0] != constants[2]); + computedConstants[4] = constants[1] < constants[0]; + computedConstants[5] = constants[1]/(constants[0] < constants[2]); + computedConstants[6] = constants[1] <= constants[0]; + computedConstants[7] = constants[1]/(constants[0] <= constants[2]); + computedConstants[8] = constants[1] > constants[0]; + computedConstants[9] = constants[1]/(constants[0] > constants[2]); + computedConstants[10] = constants[1] >= constants[0]; + computedConstants[11] = constants[1]/(constants[0] >= constants[2]); + computedConstants[12] = constants[1] && constants[0]; + computedConstants[13] = constants[1] && constants[0] && constants[2]; + computedConstants[14] = (constants[1] < constants[0]) && (constants[2] > constants[3]); + computedConstants[15] = (constants[1]+constants[0]) && (constants[2] > constants[3]); + computedConstants[16] = constants[1] && (constants[0] > constants[2]); + computedConstants[17] = (constants[1]-constants[0]) && (constants[2] > constants[3]); + computedConstants[18] = -constants[1] && (constants[0] > constants[2]); + computedConstants[19] = (constants[1]^^constants[0]) && (constants[2] > constants[3]); + computedConstants[20] = (constants[1]^^(1.0/constants[0])) && (constants[2] > constants[3]); + computedConstants[21] = (constants[1] < constants[0]) && (constants[2]+constants[3]); + computedConstants[22] = (constants[1] < constants[0]) && constants[2]; + computedConstants[23] = (constants[1] < constants[0]) && (constants[2]-constants[3]); + computedConstants[24] = (constants[1] < constants[0]) && -constants[2]; + computedConstants[25] = (constants[1] < constants[0]) && (constants[2]^^constants[3]); + computedConstants[26] = (constants[1] < constants[0]) && (constants[2]^^(1.0/constants[3])); + computedConstants[27] = constants[1]/(constants[0] && constants[2]); + computedConstants[28] = constants[1] || constants[0]; + computedConstants[29] = constants[1] || constants[0] || constants[2]; + computedConstants[30] = (constants[1] < constants[0]) || (constants[2] > constants[3]); + computedConstants[31] = (constants[1]+constants[0]) || (constants[2] > constants[3]); + computedConstants[32] = constants[1] || (constants[0] > constants[2]); + computedConstants[33] = (constants[1]-constants[0]) || (constants[2] > constants[3]); + computedConstants[34] = -constants[1] || (constants[0] > constants[2]); + computedConstants[35] = (constants[1]^^constants[0]) || (constants[2] > constants[3]); + computedConstants[36] = (constants[1]^^(1.0/constants[0])) || (constants[2] > constants[3]); + computedConstants[37] = (constants[1] < constants[0]) || (constants[2]+constants[3]); + computedConstants[38] = (constants[1] < constants[0]) || constants[2]; + computedConstants[39] = (constants[1] < constants[0]) || (constants[2]-constants[3]); + computedConstants[40] = (constants[1] < constants[0]) || -constants[2]; + computedConstants[41] = (constants[1] < constants[0]) || (constants[2]^^constants[3]); + computedConstants[42] = (constants[1] < constants[0]) || (constants[2]^^(1.0/constants[3])); + computedConstants[43] = constants[1]/(constants[0] || constants[2]); + computedConstants[44] = constants[1]^constants[0]; + computedConstants[45] = constants[1]^constants[0]^constants[2]; + computedConstants[46] = (constants[1] < constants[0])^(constants[2] > constants[3]); + computedConstants[47] = (constants[1]+constants[0])^(constants[2] > constants[3]); + computedConstants[48] = constants[1]^(constants[0] > constants[2]); + computedConstants[49] = (constants[1]-constants[0])^(constants[2] > constants[3]); + computedConstants[50] = -constants[1]^(constants[0] > constants[2]); + computedConstants[51] = (constants[1]^^constants[0])^(constants[2] > constants[3]); + computedConstants[52] = (constants[1]^^(1.0/constants[0]))^(constants[2] > constants[3]); + computedConstants[53] = (constants[1] < constants[0])^(constants[2]+constants[3]); + computedConstants[54] = (constants[1] < constants[0])^constants[2]; + computedConstants[55] = (constants[1] < constants[0])^(constants[2]-constants[3]); + computedConstants[56] = (constants[1] < constants[0])^-constants[2]; + computedConstants[57] = (constants[1] < constants[0])^(constants[2]^^constants[3]); + computedConstants[58] = (constants[1] < constants[0])^(constants[2]^^(1.0/constants[3])); + computedConstants[59] = constants[1]/(constants[0]^constants[2]); + computedConstants[60] = !constants[1]; + computedConstants[61] = constants[1]+constants[0]+constants[2]; + computedConstants[62] = (constants[1] < constants[0])+(constants[2] > constants[3]); + computedConstants[63] = constants[1]; + computedConstants[64] = constants[1]-constants[0]; + computedConstants[65] = (constants[1] < constants[0])-(constants[2] > constants[3]); + computedConstants[66] = (constants[1] < constants[0])-(constants[2]+constants[3]); + computedConstants[67] = (constants[1] < constants[0])-constants[2]; + computedConstants[68] = constants[1]-(-constants[0]); + computedConstants[69] = constants[1]-(-constants[0]*constants[2]); + computedConstants[70] = -constants[1]; + computedConstants[71] = -(constants[1] < constants[0]); + computedConstants[72] = constants[1]*constants[0]; + computedConstants[73] = constants[1]*constants[0]*constants[2]; + computedConstants[74] = (constants[1] < constants[0])*(constants[2] > constants[3]); + computedConstants[75] = (constants[1]+constants[0])*(constants[2] > constants[3]); + computedConstants[76] = constants[1]*(constants[0] > constants[2]); + computedConstants[77] = (constants[1]-constants[0])*(constants[2] > constants[3]); + computedConstants[78] = -constants[1]*(constants[0] > constants[2]); + computedConstants[79] = (constants[1] < constants[0])*(constants[2]+constants[3]); + computedConstants[80] = (constants[1] < constants[0])*constants[2]; + computedConstants[81] = (constants[1] < constants[0])*(constants[2]-constants[3]); + computedConstants[82] = (constants[1] < constants[0])*-constants[2]; + computedConstants[83] = constants[1]/constants[0]; + computedConstants[84] = (constants[1] < constants[0])/(constants[3] > constants[2]); + computedConstants[85] = (constants[1]+constants[0])/(constants[3] > constants[2]); + computedConstants[86] = constants[1]/(constants[2] > constants[0]); + computedConstants[87] = (constants[1]-constants[0])/(constants[3] > constants[2]); + computedConstants[88] = -constants[1]/(constants[2] > constants[0]); + computedConstants[89] = (constants[1] < constants[0])/(constants[2]+constants[3]); + computedConstants[90] = (constants[1] < constants[0])/constants[2]; + computedConstants[91] = (constants[1] < constants[0])/(constants[2]-constants[3]); + computedConstants[92] = (constants[1] < constants[0])/-constants[2]; + computedConstants[93] = (constants[1] < constants[0])/(constants[2]*constants[3]); + computedConstants[94] = (constants[1] < constants[0])/(constants[2]/constants[3]); + computedConstants[95] = sqrt(constants[1]); + computedConstants[96] = sqr(constants[1]); + computedConstants[97] = constants[1]^^3.0; + computedConstants[98] = constants[1]^^constants[0]; + computedConstants[99] = (constants[1] <= constants[0])^^(constants[2] >= constants[3]); + computedConstants[100] = (constants[1]+constants[0])^^(constants[2] >= constants[3]); + computedConstants[101] = constants[1]^^(constants[0] >= constants[2]); + computedConstants[102] = (constants[1]-constants[0])^^(constants[2] >= constants[3]); + computedConstants[103] = (-constants[1])^^(constants[0] >= constants[2]); + computedConstants[104] = (constants[1]*constants[0])^^(constants[2] >= constants[3]); + computedConstants[105] = (constants[1]/constants[0])^^(constants[2] >= constants[3]); + computedConstants[106] = (constants[1] <= constants[0])^^(constants[2]+constants[3]); + computedConstants[107] = (constants[1] <= constants[0])^^constants[2]; + computedConstants[108] = (constants[1] <= constants[0])^^constants[2]-constants[3]; + computedConstants[109] = (constants[1] <= constants[0])^^-constants[2]; + computedConstants[110] = (constants[1] <= constants[0])^^(constants[2]*constants[3]); + computedConstants[111] = (constants[1] <= constants[0])^^(constants[2]/constants[3]); + computedConstants[112] = (constants[1] <= constants[0])^^(constants[2]^^constants[3]); + computedConstants[113] = (constants[1] <= constants[0])^^(constants[2]^^(1.0/constants[3])); + computedConstants[114] = sqrt(constants[1]); + computedConstants[115] = sqrt(constants[1]); + computedConstants[116] = constants[1]^^(1.0/3.0); + computedConstants[117] = constants[1]^^(1.0/constants[0]); + computedConstants[118] = (constants[1] < constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[119] = (constants[1]+constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[120] = constants[1]^^(1.0/(constants[2] > constants[0])); + computedConstants[121] = (constants[1]-constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[122] = (-constants[1])^^(1.0/(constants[2] > constants[0])); + computedConstants[123] = (constants[1]*constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[124] = (constants[1]/constants[0])^^(1.0/(constants[3] > constants[2])); + computedConstants[125] = (constants[1] < constants[0])^^(1.0/(constants[2]+constants[3])); + computedConstants[126] = (constants[1] < constants[0])^^(1.0/constants[2]); + computedConstants[127] = (constants[1] < constants[0])^^(1.0/(constants[2]-constants[3])); + computedConstants[128] = (constants[1] < constants[0])^^(1.0/(-constants[2])); + computedConstants[129] = (constants[1] < constants[0])^^(1.0/(constants[2]*constants[3])); + computedConstants[130] = (constants[1] < constants[0])^^(1.0/(constants[2]/constants[3])); + computedConstants[131] = (constants[1] < constants[0])^^(1.0/(constants[2]^^constants[3])); + computedConstants[132] = (constants[1] < constants[0])^^(1.0/(constants[2]^^(1.0/constants[3]))); + computedConstants[133] = fabs(constants[1]); + computedConstants[134] = exp(constants[1]); + computedConstants[135] = log(constants[1]); + computedConstants[136] = log10(constants[1]); + computedConstants[137] = log(constants[1])/log(2.0); + computedConstants[138] = log10(constants[1]); + computedConstants[139] = log(constants[1])/log(constants[0]); + computedConstants[140] = ceil(constants[1]); + computedConstants[141] = floor(constants[1]); + computedConstants[142] = min(constants[1], constants[0]); + computedConstants[143] = min(constants[1], min(constants[0], constants[2])); + computedConstants[144] = max(constants[1], constants[0]); + computedConstants[145] = max(constants[1], max(constants[0], constants[2])); + computedConstants[146] = fmod(constants[1], constants[0]); + computedConstants[147] = sin(constants[1]); + computedConstants[148] = cos(constants[1]); + computedConstants[149] = tan(constants[1]); + computedConstants[150] = sec(constants[1]); + computedConstants[151] = csc(constants[1]); + computedConstants[152] = cot(constants[1]); + computedConstants[153] = sinh(constants[1]); + computedConstants[154] = cosh(constants[1]); + computedConstants[155] = tanh(constants[1]); + computedConstants[156] = sech(constants[1]); + computedConstants[157] = csch(constants[1]); + computedConstants[158] = coth(constants[1]); + computedConstants[159] = asin(constants[1]); + computedConstants[160] = acos(constants[1]); + computedConstants[161] = atan(constants[1]); + computedConstants[162] = asec(constants[1]); + computedConstants[163] = acsc(constants[1]); + computedConstants[164] = acot(constants[1]); + computedConstants[165] = asinh(constants[1]); + computedConstants[166] = acosh(constants[1]); + computedConstants[167] = atanh(constants[1]/2.0); + computedConstants[168] = asech(constants[1]); + computedConstants[169] = acsch(constants[1]); + computedConstants[170] = acoth(2.0*constants[1]); + computedConstants[171] = piecewise(constants[1] > constants[0], constants[1], NAN); + computedConstants[172] = piecewise(constants[1] > constants[0], constants[1], constants[2]); + computedConstants[173] = piecewise(constants[1] > constants[0], constants[1], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], NAN))); + computedConstants[174] = piecewise(constants[1] > constants[0], constants[1], piecewise(constants[2] > constants[3], constants[2], piecewise(constants[4] > constants[5], constants[4], constants[6]))); + computedConstants[175] = 123.0+piecewise(constants[1] > constants[0], constants[1], NAN); + computedConstants[180] = constants[1]; + computedConstants[187] = (constants[1] && constants[0])+piecewise(constants[2] > constants[3], constants[0], NAN)+constants[4]+(constants[5] && constants[6]); + computedConstants[188] = (constants[1] && constants[0])-(piecewise(constants[2] > constants[3], constants[0], NAN)-(constants[4]-piecewise(constants[2] > constants[3], constants[0], NAN)))-(constants[5] && constants[6]); + computedConstants[189] = (constants[1] && constants[0])*piecewise(constants[2] > constants[3], constants[0], NAN)*constants[4]*piecewise(constants[2] > constants[3], constants[0], NAN)*(constants[5] && constants[6]); + computedConstants[190] = (constants[1] && constants[0])/(piecewise(constants[2] > constants[3], constants[0], NAN)/(constants[4]/piecewise(constants[2] > constants[3], constants[0], NAN))); + computedConstants[191] = (constants[1] || constants[0]) && (constants[1]^constants[0]) && piecewise(constants[2] > constants[3], constants[0], NAN) && constants[4] && piecewise(constants[2] > constants[3], constants[0], NAN) && (constants[1]^constants[0]) && (constants[1] || constants[0]); + computedConstants[192] = (constants[1] && constants[0]) || (constants[1]^constants[0]) || piecewise(constants[2] > constants[3], constants[0], NAN) || constants[4] || piecewise(constants[2] > constants[3], constants[0], NAN) || (constants[1]^constants[0]) || (constants[1] && constants[0]); + computedConstants[193] = (constants[1] && constants[0])^(constants[1] || constants[0])^piecewise(constants[2] > constants[3], constants[0], NAN)^constants[4]^piecewise(constants[2] > constants[3], constants[0], NAN)^(constants[1] || constants[0])^(constants[1] && constants[0]); + computedConstants[194] = (constants[1] && constants[0])^^(piecewise(constants[2] > constants[3], constants[0], NAN)^^(constants[4]^^piecewise(constants[2] > constants[3], constants[0], NAN)^^(constants[1] && constants[0]))); + computedConstants[195] = (constants[1] && constants[0])^^(1.0/(piecewise(constants[2] > constants[3], constants[0], NAN)^^(1.0/constants[4])))^^(1.0/piecewise(constants[2] > constants[3], constants[0], NAN))^^(1.0/(constants[1] && constants[0])); + computedConstants[196] = -(constants[1] && constants[0])+-piecewise(constants[2] > constants[3], constants[0], NAN); } void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 160d44a84..2e597879a 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -20,8 +20,8 @@ ] CONSTANT_INFO = [ - {"name": "m", "units": "dimensionless", "component": "my_component"}, {"name": "n", "units": "dimensionless", "component": "my_component"}, + {"name": "m", "units": "dimensionless", "component": "my_component"}, {"name": "o", "units": "dimensionless", "component": "my_component"}, {"name": "p", "units": "dimensionless", "component": "my_component"}, {"name": "q", "units": "dimensionless", "component": "my_component"}, @@ -227,13 +227,13 @@ {"name": "eqnCoverageForPowerOperator", "units": "dimensionless", "component": "my_component"}, {"name": "eqnCoverageForRootOperator", "units": "dimensionless", "component": "my_component"}, {"name": "eqnCoverageForMinusUnary", "units": "dimensionless", "component": "my_component"}, - {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"}, - {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"} + {"name": "eqnComputedConstant2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnComputedConstant1", "units": "dimensionless", "component": "my_component"} ] ALGEBRAIC_INFO = [ - {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component"}, - {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"} + {"name": "eqnNlaVariable2", "units": "dimensionless", "component": "my_component"}, + {"name": "eqnNlaVariable1", "units": "dimensionless", "component": "my_component"} ] EXTERNAL_INFO = [ @@ -378,8 +378,8 @@ def objective_function_0(u, f, data): algebraic[0] = u[0] algebraic[1] = u[1] - f[0] = algebraic[0]+algebraic[1]+states[0]-0.0 - f[1] = algebraic[0]-algebraic[1]-(computed_constants[197]+computed_constants[198]) + f[0] = algebraic[1]+algebraic[0]+states[0]-0.0 + f[1] = algebraic[1]-algebraic[0]-(computed_constants[198]+computed_constants[197]) def find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals): @@ -396,8 +396,8 @@ def find_root_0(voi, states, rates, constants, computed_constants, algebraic, ex def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = 0.0 - constants[0] = 1.0 - constants[1] = 2.0 + constants[0] = 2.0 + constants[1] = 1.0 constants[2] = 3.0 constants[3] = 4.0 constants[4] = 5.0 @@ -413,200 +413,200 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic computed_constants[184] = 3.14159265358979 computed_constants[185] = inf computed_constants[186] = nan - computed_constants[197] = 1.0 - computed_constants[198] = 3.0 - algebraic[0] = 1.0 - algebraic[1] = 2.0 + computed_constants[198] = 1.0 + computed_constants[197] = 3.0 + algebraic[0] = 2.0 + algebraic[1] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = eq_func(constants[0], constants[1]) - computed_constants[1] = constants[0]/eq_func(constants[1], constants[1]) - computed_constants[2] = neq_func(constants[0], constants[1]) - computed_constants[3] = constants[0]/neq_func(constants[1], constants[2]) - computed_constants[4] = lt_func(constants[0], constants[1]) - computed_constants[5] = constants[0]/lt_func(constants[1], constants[2]) - computed_constants[6] = leq_func(constants[0], constants[1]) - computed_constants[7] = constants[0]/leq_func(constants[1], constants[2]) - computed_constants[8] = gt_func(constants[0], constants[1]) - computed_constants[9] = constants[0]/gt_func(constants[1], constants[2]) - computed_constants[10] = geq_func(constants[0], constants[1]) - computed_constants[11] = constants[0]/geq_func(constants[1], constants[2]) - computed_constants[12] = and_func(constants[0], constants[1]) - computed_constants[13] = and_func(constants[0], and_func(constants[1], constants[2])) - computed_constants[14] = and_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[15] = and_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) - computed_constants[16] = and_func(constants[0], gt_func(constants[1], constants[2])) - computed_constants[17] = and_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) - computed_constants[18] = and_func(-constants[0], gt_func(constants[1], constants[2])) - computed_constants[19] = and_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[20] = and_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) - computed_constants[21] = and_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) - computed_constants[22] = and_func(lt_func(constants[0], constants[1]), constants[2]) - computed_constants[23] = and_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) - computed_constants[24] = and_func(lt_func(constants[0], constants[1]), -constants[2]) - computed_constants[25] = and_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) - computed_constants[26] = and_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) - computed_constants[27] = constants[0]/and_func(constants[1], constants[2]) - computed_constants[28] = or_func(constants[0], constants[1]) - computed_constants[29] = or_func(constants[0], or_func(constants[1], constants[2])) - computed_constants[30] = or_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[31] = or_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) - computed_constants[32] = or_func(constants[0], gt_func(constants[1], constants[2])) - computed_constants[33] = or_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) - computed_constants[34] = or_func(-constants[0], gt_func(constants[1], constants[2])) - computed_constants[35] = or_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[36] = or_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) - computed_constants[37] = or_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) - computed_constants[38] = or_func(lt_func(constants[0], constants[1]), constants[2]) - computed_constants[39] = or_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) - computed_constants[40] = or_func(lt_func(constants[0], constants[1]), -constants[2]) - computed_constants[41] = or_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) - computed_constants[42] = or_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) - computed_constants[43] = constants[0]/or_func(constants[1], constants[2]) - computed_constants[44] = xor_func(constants[0], constants[1]) - computed_constants[45] = xor_func(constants[0], xor_func(constants[1], constants[2])) - computed_constants[46] = xor_func(lt_func(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[47] = xor_func(constants[0]+constants[1], gt_func(constants[2], constants[3])) - computed_constants[48] = xor_func(constants[0], gt_func(constants[1], constants[2])) - computed_constants[49] = xor_func(constants[0]-constants[1], gt_func(constants[2], constants[3])) - computed_constants[50] = xor_func(-constants[0], gt_func(constants[1], constants[2])) - computed_constants[51] = xor_func(pow(constants[0], constants[1]), gt_func(constants[2], constants[3])) - computed_constants[52] = xor_func(pow(constants[0], 1.0/constants[1]), gt_func(constants[2], constants[3])) - computed_constants[53] = xor_func(lt_func(constants[0], constants[1]), constants[2]+constants[3]) - computed_constants[54] = xor_func(lt_func(constants[0], constants[1]), constants[2]) - computed_constants[55] = xor_func(lt_func(constants[0], constants[1]), constants[2]-constants[3]) - computed_constants[56] = xor_func(lt_func(constants[0], constants[1]), -constants[2]) - computed_constants[57] = xor_func(lt_func(constants[0], constants[1]), pow(constants[2], constants[3])) - computed_constants[58] = xor_func(lt_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) - computed_constants[59] = constants[0]/xor_func(constants[1], constants[2]) - computed_constants[60] = not_func(constants[0]) - computed_constants[61] = constants[0]+constants[1]+constants[2] - computed_constants[62] = lt_func(constants[0], constants[1])+gt_func(constants[2], constants[3]) - computed_constants[63] = constants[0] - computed_constants[64] = constants[0]-constants[1] - computed_constants[65] = lt_func(constants[0], constants[1])-gt_func(constants[2], constants[3]) - computed_constants[66] = lt_func(constants[0], constants[1])-(constants[2]+constants[3]) - computed_constants[67] = lt_func(constants[0], constants[1])-constants[2] - computed_constants[68] = constants[0]-(-constants[1]) - computed_constants[69] = constants[0]-(-constants[1]*constants[2]) - computed_constants[70] = -constants[0] - computed_constants[71] = -lt_func(constants[0], constants[1]) - computed_constants[72] = constants[0]*constants[1] - computed_constants[73] = constants[0]*constants[1]*constants[2] - computed_constants[74] = lt_func(constants[0], constants[1])*gt_func(constants[2], constants[3]) - computed_constants[75] = (constants[0]+constants[1])*gt_func(constants[2], constants[3]) - computed_constants[76] = constants[0]*gt_func(constants[1], constants[2]) - computed_constants[77] = (constants[0]-constants[1])*gt_func(constants[2], constants[3]) - computed_constants[78] = -constants[0]*gt_func(constants[1], constants[2]) - computed_constants[79] = lt_func(constants[0], constants[1])*(constants[2]+constants[3]) - computed_constants[80] = lt_func(constants[0], constants[1])*constants[2] - computed_constants[81] = lt_func(constants[0], constants[1])*(constants[2]-constants[3]) - computed_constants[82] = lt_func(constants[0], constants[1])*-constants[2] - computed_constants[83] = constants[0]/constants[1] - computed_constants[84] = lt_func(constants[0], constants[1])/gt_func(constants[3], constants[2]) - computed_constants[85] = (constants[0]+constants[1])/gt_func(constants[3], constants[2]) - computed_constants[86] = constants[0]/gt_func(constants[2], constants[1]) - computed_constants[87] = (constants[0]-constants[1])/gt_func(constants[3], constants[2]) - computed_constants[88] = -constants[0]/gt_func(constants[2], constants[1]) - computed_constants[89] = lt_func(constants[0], constants[1])/(constants[2]+constants[3]) - computed_constants[90] = lt_func(constants[0], constants[1])/constants[2] - computed_constants[91] = lt_func(constants[0], constants[1])/(constants[2]-constants[3]) - computed_constants[92] = lt_func(constants[0], constants[1])/-constants[2] - computed_constants[93] = lt_func(constants[0], constants[1])/(constants[2]*constants[3]) - computed_constants[94] = lt_func(constants[0], constants[1])/(constants[2]/constants[3]) - computed_constants[95] = sqrt(constants[0]) - computed_constants[96] = pow(constants[0], 2.0) - computed_constants[97] = pow(constants[0], 3.0) - computed_constants[98] = pow(constants[0], constants[1]) - computed_constants[99] = pow(leq_func(constants[0], constants[1]), geq_func(constants[2], constants[3])) - computed_constants[100] = pow(constants[0]+constants[1], geq_func(constants[2], constants[3])) - computed_constants[101] = pow(constants[0], geq_func(constants[1], constants[2])) - computed_constants[102] = pow(constants[0]-constants[1], geq_func(constants[2], constants[3])) - computed_constants[103] = pow(-constants[0], geq_func(constants[1], constants[2])) - computed_constants[104] = pow(constants[0]*constants[1], geq_func(constants[2], constants[3])) - computed_constants[105] = pow(constants[0]/constants[1], geq_func(constants[2], constants[3])) - computed_constants[106] = pow(leq_func(constants[0], constants[1]), constants[2]+constants[3]) - computed_constants[107] = pow(leq_func(constants[0], constants[1]), constants[2]) - computed_constants[108] = pow(leq_func(constants[0], constants[1]), constants[2]-constants[3]) - computed_constants[109] = pow(leq_func(constants[0], constants[1]), -constants[2]) - computed_constants[110] = pow(leq_func(constants[0], constants[1]), constants[2]*constants[3]) - computed_constants[111] = pow(leq_func(constants[0], constants[1]), constants[2]/constants[3]) - computed_constants[112] = pow(leq_func(constants[0], constants[1]), pow(constants[2], constants[3])) - computed_constants[113] = pow(leq_func(constants[0], constants[1]), pow(constants[2], 1.0/constants[3])) - computed_constants[114] = sqrt(constants[0]) - computed_constants[115] = sqrt(constants[0]) - computed_constants[116] = pow(constants[0], 1.0/3.0) - computed_constants[117] = pow(constants[0], 1.0/constants[1]) - computed_constants[118] = pow(lt_func(constants[0], constants[1]), 1.0/gt_func(constants[3], constants[2])) - computed_constants[119] = pow(constants[0]+constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[120] = pow(constants[0], 1.0/gt_func(constants[2], constants[1])) - computed_constants[121] = pow(constants[0]-constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[122] = pow(-constants[0], 1.0/gt_func(constants[2], constants[1])) - computed_constants[123] = pow(constants[0]*constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[124] = pow(constants[0]/constants[1], 1.0/gt_func(constants[3], constants[2])) - computed_constants[125] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]+constants[3])) - computed_constants[126] = pow(lt_func(constants[0], constants[1]), 1.0/constants[2]) - computed_constants[127] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]-constants[3])) - computed_constants[128] = pow(lt_func(constants[0], constants[1]), 1.0/-constants[2]) - computed_constants[129] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]*constants[3])) - computed_constants[130] = pow(lt_func(constants[0], constants[1]), 1.0/(constants[2]/constants[3])) - computed_constants[131] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], constants[3])) - computed_constants[132] = pow(lt_func(constants[0], constants[1]), 1.0/pow(constants[2], 1.0/constants[3])) - computed_constants[133] = fabs(constants[0]) - computed_constants[134] = exp(constants[0]) - computed_constants[135] = log(constants[0]) - computed_constants[136] = log10(constants[0]) - computed_constants[137] = log(constants[0])/log(2.0) - computed_constants[138] = log10(constants[0]) - computed_constants[139] = log(constants[0])/log(constants[1]) - computed_constants[140] = ceil(constants[0]) - computed_constants[141] = floor(constants[0]) - computed_constants[142] = min(constants[0], constants[1]) - computed_constants[143] = min(constants[0], min(constants[1], constants[2])) - computed_constants[144] = max(constants[0], constants[1]) - computed_constants[145] = max(constants[0], max(constants[1], constants[2])) - computed_constants[146] = fmod(constants[0], constants[1]) - computed_constants[147] = sin(constants[0]) - computed_constants[148] = cos(constants[0]) - computed_constants[149] = tan(constants[0]) - computed_constants[150] = sec(constants[0]) - computed_constants[151] = csc(constants[0]) - computed_constants[152] = cot(constants[0]) - computed_constants[153] = sinh(constants[0]) - computed_constants[154] = cosh(constants[0]) - computed_constants[155] = tanh(constants[0]) - computed_constants[156] = sech(constants[0]) - computed_constants[157] = csch(constants[0]) - computed_constants[158] = coth(constants[0]) - computed_constants[159] = asin(constants[0]) - computed_constants[160] = acos(constants[0]) - computed_constants[161] = atan(constants[0]) - computed_constants[162] = asec(constants[0]) - computed_constants[163] = acsc(constants[0]) - computed_constants[164] = acot(constants[0]) - computed_constants[165] = asinh(constants[0]) - computed_constants[166] = acosh(constants[0]) - computed_constants[167] = atanh(constants[0]/2.0) - computed_constants[168] = asech(constants[0]) - computed_constants[169] = acsch(constants[0]) - computed_constants[170] = acoth(2.0*constants[0]) - computed_constants[171] = constants[0] if gt_func(constants[0], constants[1]) else nan - computed_constants[172] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] - computed_constants[173] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan - computed_constants[174] = constants[0] if gt_func(constants[0], constants[1]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] - computed_constants[175] = 123.0+(constants[0] if gt_func(constants[0], constants[1]) else nan) - computed_constants[180] = constants[0] - computed_constants[187] = and_func(constants[0], constants[1])+(constants[1] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) - computed_constants[188] = and_func(constants[0], constants[1])-((constants[1] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[1] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) - computed_constants[189] = and_func(constants[0], constants[1])*(constants[1] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[1] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) - computed_constants[190] = and_func(constants[0], constants[1])/((constants[1] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[1] if gt_func(constants[2], constants[3]) else nan))) - computed_constants[191] = and_func(or_func(constants[0], constants[1]), and_func(xor_func(constants[0], constants[1]), and_func(constants[1] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), or_func(constants[0], constants[1]))))) - computed_constants[192] = or_func(and_func(constants[0], constants[1]), or_func(xor_func(constants[0], constants[1]), or_func(constants[1] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) - computed_constants[193] = xor_func(and_func(constants[0], constants[1]), xor_func(or_func(constants[0], constants[1]), xor_func(constants[1] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), or_func(constants[0], constants[1])), and_func(constants[0], constants[1]))))) - computed_constants[194] = pow(and_func(constants[0], constants[1]), pow(constants[1] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[1] if gt_func(constants[2], constants[3]) else nan), and_func(constants[0], constants[1])))) - computed_constants[195] = pow(pow(pow(and_func(constants[0], constants[1]), 1.0/pow(constants[1] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[1] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[0], constants[1])) - computed_constants[196] = -and_func(constants[0], constants[1])+-(constants[1] if gt_func(constants[2], constants[3]) else nan) + computed_constants[0] = eq_func(constants[1], constants[0]) + computed_constants[1] = constants[1]/eq_func(constants[0], constants[0]) + computed_constants[2] = neq_func(constants[1], constants[0]) + computed_constants[3] = constants[1]/neq_func(constants[0], constants[2]) + computed_constants[4] = lt_func(constants[1], constants[0]) + computed_constants[5] = constants[1]/lt_func(constants[0], constants[2]) + computed_constants[6] = leq_func(constants[1], constants[0]) + computed_constants[7] = constants[1]/leq_func(constants[0], constants[2]) + computed_constants[8] = gt_func(constants[1], constants[0]) + computed_constants[9] = constants[1]/gt_func(constants[0], constants[2]) + computed_constants[10] = geq_func(constants[1], constants[0]) + computed_constants[11] = constants[1]/geq_func(constants[0], constants[2]) + computed_constants[12] = and_func(constants[1], constants[0]) + computed_constants[13] = and_func(constants[1], and_func(constants[0], constants[2])) + computed_constants[14] = and_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[15] = and_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[16] = and_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[17] = and_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[18] = and_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[19] = and_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[20] = and_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[21] = and_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[22] = and_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[23] = and_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[24] = and_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[25] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[26] = and_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[27] = constants[1]/and_func(constants[0], constants[2]) + computed_constants[28] = or_func(constants[1], constants[0]) + computed_constants[29] = or_func(constants[1], or_func(constants[0], constants[2])) + computed_constants[30] = or_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[31] = or_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[32] = or_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[33] = or_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[34] = or_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[35] = or_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[36] = or_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[37] = or_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[38] = or_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[39] = or_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[40] = or_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[41] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[42] = or_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[43] = constants[1]/or_func(constants[0], constants[2]) + computed_constants[44] = xor_func(constants[1], constants[0]) + computed_constants[45] = xor_func(constants[1], xor_func(constants[0], constants[2])) + computed_constants[46] = xor_func(lt_func(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[47] = xor_func(constants[1]+constants[0], gt_func(constants[2], constants[3])) + computed_constants[48] = xor_func(constants[1], gt_func(constants[0], constants[2])) + computed_constants[49] = xor_func(constants[1]-constants[0], gt_func(constants[2], constants[3])) + computed_constants[50] = xor_func(-constants[1], gt_func(constants[0], constants[2])) + computed_constants[51] = xor_func(pow(constants[1], constants[0]), gt_func(constants[2], constants[3])) + computed_constants[52] = xor_func(pow(constants[1], 1.0/constants[0]), gt_func(constants[2], constants[3])) + computed_constants[53] = xor_func(lt_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[54] = xor_func(lt_func(constants[1], constants[0]), constants[2]) + computed_constants[55] = xor_func(lt_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[56] = xor_func(lt_func(constants[1], constants[0]), -constants[2]) + computed_constants[57] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[58] = xor_func(lt_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[59] = constants[1]/xor_func(constants[0], constants[2]) + computed_constants[60] = not_func(constants[1]) + computed_constants[61] = constants[1]+constants[0]+constants[2] + computed_constants[62] = lt_func(constants[1], constants[0])+gt_func(constants[2], constants[3]) + computed_constants[63] = constants[1] + computed_constants[64] = constants[1]-constants[0] + computed_constants[65] = lt_func(constants[1], constants[0])-gt_func(constants[2], constants[3]) + computed_constants[66] = lt_func(constants[1], constants[0])-(constants[2]+constants[3]) + computed_constants[67] = lt_func(constants[1], constants[0])-constants[2] + computed_constants[68] = constants[1]-(-constants[0]) + computed_constants[69] = constants[1]-(-constants[0]*constants[2]) + computed_constants[70] = -constants[1] + computed_constants[71] = -lt_func(constants[1], constants[0]) + computed_constants[72] = constants[1]*constants[0] + computed_constants[73] = constants[1]*constants[0]*constants[2] + computed_constants[74] = lt_func(constants[1], constants[0])*gt_func(constants[2], constants[3]) + computed_constants[75] = (constants[1]+constants[0])*gt_func(constants[2], constants[3]) + computed_constants[76] = constants[1]*gt_func(constants[0], constants[2]) + computed_constants[77] = (constants[1]-constants[0])*gt_func(constants[2], constants[3]) + computed_constants[78] = -constants[1]*gt_func(constants[0], constants[2]) + computed_constants[79] = lt_func(constants[1], constants[0])*(constants[2]+constants[3]) + computed_constants[80] = lt_func(constants[1], constants[0])*constants[2] + computed_constants[81] = lt_func(constants[1], constants[0])*(constants[2]-constants[3]) + computed_constants[82] = lt_func(constants[1], constants[0])*-constants[2] + computed_constants[83] = constants[1]/constants[0] + computed_constants[84] = lt_func(constants[1], constants[0])/gt_func(constants[3], constants[2]) + computed_constants[85] = (constants[1]+constants[0])/gt_func(constants[3], constants[2]) + computed_constants[86] = constants[1]/gt_func(constants[2], constants[0]) + computed_constants[87] = (constants[1]-constants[0])/gt_func(constants[3], constants[2]) + computed_constants[88] = -constants[1]/gt_func(constants[2], constants[0]) + computed_constants[89] = lt_func(constants[1], constants[0])/(constants[2]+constants[3]) + computed_constants[90] = lt_func(constants[1], constants[0])/constants[2] + computed_constants[91] = lt_func(constants[1], constants[0])/(constants[2]-constants[3]) + computed_constants[92] = lt_func(constants[1], constants[0])/-constants[2] + computed_constants[93] = lt_func(constants[1], constants[0])/(constants[2]*constants[3]) + computed_constants[94] = lt_func(constants[1], constants[0])/(constants[2]/constants[3]) + computed_constants[95] = sqrt(constants[1]) + computed_constants[96] = pow(constants[1], 2.0) + computed_constants[97] = pow(constants[1], 3.0) + computed_constants[98] = pow(constants[1], constants[0]) + computed_constants[99] = pow(leq_func(constants[1], constants[0]), geq_func(constants[2], constants[3])) + computed_constants[100] = pow(constants[1]+constants[0], geq_func(constants[2], constants[3])) + computed_constants[101] = pow(constants[1], geq_func(constants[0], constants[2])) + computed_constants[102] = pow(constants[1]-constants[0], geq_func(constants[2], constants[3])) + computed_constants[103] = pow(-constants[1], geq_func(constants[0], constants[2])) + computed_constants[104] = pow(constants[1]*constants[0], geq_func(constants[2], constants[3])) + computed_constants[105] = pow(constants[1]/constants[0], geq_func(constants[2], constants[3])) + computed_constants[106] = pow(leq_func(constants[1], constants[0]), constants[2]+constants[3]) + computed_constants[107] = pow(leq_func(constants[1], constants[0]), constants[2]) + computed_constants[108] = pow(leq_func(constants[1], constants[0]), constants[2]-constants[3]) + computed_constants[109] = pow(leq_func(constants[1], constants[0]), -constants[2]) + computed_constants[110] = pow(leq_func(constants[1], constants[0]), constants[2]*constants[3]) + computed_constants[111] = pow(leq_func(constants[1], constants[0]), constants[2]/constants[3]) + computed_constants[112] = pow(leq_func(constants[1], constants[0]), pow(constants[2], constants[3])) + computed_constants[113] = pow(leq_func(constants[1], constants[0]), pow(constants[2], 1.0/constants[3])) + computed_constants[114] = sqrt(constants[1]) + computed_constants[115] = sqrt(constants[1]) + computed_constants[116] = pow(constants[1], 1.0/3.0) + computed_constants[117] = pow(constants[1], 1.0/constants[0]) + computed_constants[118] = pow(lt_func(constants[1], constants[0]), 1.0/gt_func(constants[3], constants[2])) + computed_constants[119] = pow(constants[1]+constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[120] = pow(constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[121] = pow(constants[1]-constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[122] = pow(-constants[1], 1.0/gt_func(constants[2], constants[0])) + computed_constants[123] = pow(constants[1]*constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[124] = pow(constants[1]/constants[0], 1.0/gt_func(constants[3], constants[2])) + computed_constants[125] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]+constants[3])) + computed_constants[126] = pow(lt_func(constants[1], constants[0]), 1.0/constants[2]) + computed_constants[127] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]-constants[3])) + computed_constants[128] = pow(lt_func(constants[1], constants[0]), 1.0/-constants[2]) + computed_constants[129] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]*constants[3])) + computed_constants[130] = pow(lt_func(constants[1], constants[0]), 1.0/(constants[2]/constants[3])) + computed_constants[131] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], constants[3])) + computed_constants[132] = pow(lt_func(constants[1], constants[0]), 1.0/pow(constants[2], 1.0/constants[3])) + computed_constants[133] = fabs(constants[1]) + computed_constants[134] = exp(constants[1]) + computed_constants[135] = log(constants[1]) + computed_constants[136] = log10(constants[1]) + computed_constants[137] = log(constants[1])/log(2.0) + computed_constants[138] = log10(constants[1]) + computed_constants[139] = log(constants[1])/log(constants[0]) + computed_constants[140] = ceil(constants[1]) + computed_constants[141] = floor(constants[1]) + computed_constants[142] = min(constants[1], constants[0]) + computed_constants[143] = min(constants[1], min(constants[0], constants[2])) + computed_constants[144] = max(constants[1], constants[0]) + computed_constants[145] = max(constants[1], max(constants[0], constants[2])) + computed_constants[146] = fmod(constants[1], constants[0]) + computed_constants[147] = sin(constants[1]) + computed_constants[148] = cos(constants[1]) + computed_constants[149] = tan(constants[1]) + computed_constants[150] = sec(constants[1]) + computed_constants[151] = csc(constants[1]) + computed_constants[152] = cot(constants[1]) + computed_constants[153] = sinh(constants[1]) + computed_constants[154] = cosh(constants[1]) + computed_constants[155] = tanh(constants[1]) + computed_constants[156] = sech(constants[1]) + computed_constants[157] = csch(constants[1]) + computed_constants[158] = coth(constants[1]) + computed_constants[159] = asin(constants[1]) + computed_constants[160] = acos(constants[1]) + computed_constants[161] = atan(constants[1]) + computed_constants[162] = asec(constants[1]) + computed_constants[163] = acsc(constants[1]) + computed_constants[164] = acot(constants[1]) + computed_constants[165] = asinh(constants[1]) + computed_constants[166] = acosh(constants[1]) + computed_constants[167] = atanh(constants[1]/2.0) + computed_constants[168] = asech(constants[1]) + computed_constants[169] = acsch(constants[1]) + computed_constants[170] = acoth(2.0*constants[1]) + computed_constants[171] = constants[1] if gt_func(constants[1], constants[0]) else nan + computed_constants[172] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] + computed_constants[173] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else nan + computed_constants[174] = constants[1] if gt_func(constants[1], constants[0]) else constants[2] if gt_func(constants[2], constants[3]) else constants[4] if gt_func(constants[4], constants[5]) else constants[6] + computed_constants[175] = 123.0+(constants[1] if gt_func(constants[1], constants[0]) else nan) + computed_constants[180] = constants[1] + computed_constants[187] = and_func(constants[1], constants[0])+(constants[0] if gt_func(constants[2], constants[3]) else nan)+constants[4]+and_func(constants[5], constants[6]) + computed_constants[188] = and_func(constants[1], constants[0])-((constants[0] if gt_func(constants[2], constants[3]) else nan)-(constants[4]-(constants[0] if gt_func(constants[2], constants[3]) else nan)))-and_func(constants[5], constants[6]) + computed_constants[189] = and_func(constants[1], constants[0])*(constants[0] if gt_func(constants[2], constants[3]) else nan)*constants[4]*(constants[0] if gt_func(constants[2], constants[3]) else nan)*and_func(constants[5], constants[6]) + computed_constants[190] = and_func(constants[1], constants[0])/((constants[0] if gt_func(constants[2], constants[3]) else nan)/(constants[4]/(constants[0] if gt_func(constants[2], constants[3]) else nan))) + computed_constants[191] = and_func(or_func(constants[1], constants[0]), and_func(xor_func(constants[1], constants[0]), and_func(constants[0] if gt_func(constants[2], constants[3]) else nan, and_func(and_func(and_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), or_func(constants[1], constants[0]))))) + computed_constants[192] = or_func(and_func(constants[1], constants[0]), or_func(xor_func(constants[1], constants[0]), or_func(constants[0] if gt_func(constants[2], constants[3]) else nan, or_func(or_func(or_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), xor_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[193] = xor_func(and_func(constants[1], constants[0]), xor_func(or_func(constants[1], constants[0]), xor_func(constants[0] if gt_func(constants[2], constants[3]) else nan, xor_func(xor_func(xor_func(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), or_func(constants[1], constants[0])), and_func(constants[1], constants[0]))))) + computed_constants[194] = pow(and_func(constants[1], constants[0]), pow(constants[0] if gt_func(constants[2], constants[3]) else nan, pow(pow(constants[4], constants[0] if gt_func(constants[2], constants[3]) else nan), and_func(constants[1], constants[0])))) + computed_constants[195] = pow(pow(pow(and_func(constants[1], constants[0]), 1.0/pow(constants[0] if gt_func(constants[2], constants[3]) else nan, 1.0/constants[4])), 1.0/(constants[0] if gt_func(constants[2], constants[3]) else nan)), 1.0/and_func(constants[1], constants[0])) + computed_constants[196] = -and_func(constants[1], constants[0])+-(constants[0] if gt_func(constants[2], constants[3]) else nan) def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index f751495ef..391d5c0f7 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -16,8 +16,8 @@ const VariableInfo CONSTANT_INFO[] = { }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { - {"x", "dimensionless", "my_algebraic_eqn"}, - {"a", "dimensionless", "my_algebraic_eqn"} + {"a", "dimensionless", "my_algebraic_eqn"}, + {"x", "dimensionless", "my_algebraic_eqn"} }; const VariableInfo ALGEBRAIC_INFO[] = { @@ -63,12 +63,12 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { - computedConstants[1] = 1.0; + computedConstants[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = computedConstants[1]; + computedConstants[1] = computedConstants[0]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index e7668f310..f79c8eaa7 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -15,8 +15,8 @@ ] COMPUTED_CONSTANT_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn"}, - {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} + {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn"} ] ALGEBRAIC_INFO = [ @@ -36,11 +36,11 @@ def create_algebraic_array(): def initialise_variables(constants, computed_constants, algebraic): - computed_constants[1] = 1.0 + computed_constants[0] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = computed_constants[1] + computed_constants[1] = computed_constants[0] def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index ea54ce0df..2a7a16f41 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -19,9 +19,9 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"x", "dimensionless", "my_algebraic_system"}, + {"z", "dimensionless", "my_algebraic_system"}, {"y", "dimensionless", "my_algebraic_system"}, - {"z", "dimensionless", "my_algebraic_system"} + {"x", "dimensionless", "my_algebraic_system"} }; double * createConstantsArray() @@ -81,9 +81,9 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[1] = u[1]; algebraic[2] = u[2]; - f[0] = 2.0*algebraic[0]+algebraic[1]-2.0*algebraic[2]-(-1.0); - f[1] = 3.0*algebraic[0]-3.0*algebraic[1]-algebraic[2]-5.0; - f[2] = algebraic[0]-2.0*algebraic[1]+3.0*algebraic[2]-6.0; + f[0] = 2.0*algebraic[2]+algebraic[1]-2.0*algebraic[0]-(-1.0); + f[1] = 3.0*algebraic[2]-3.0*algebraic[1]-algebraic[0]-5.0; + f[2] = algebraic[2]-2.0*algebraic[1]+3.0*algebraic[0]-6.0; } void findRoot0(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c index 386a0be1c..0cec3873f 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c @@ -23,9 +23,9 @@ const VariableInfo ALGEBRAIC_INFO[] = { }; const VariableInfo EXTERNAL_INFO[] = { - {"x", "dimensionless", "my_algebraic_system"}, + {"z", "dimensionless", "my_algebraic_system"}, {"y", "dimensionless", "my_algebraic_system"}, - {"z", "dimensionless", "my_algebraic_system"} + {"x", "dimensionless", "my_algebraic_system"} }; double * createConstantsArray() diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py index de0df95d2..46528e56d 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py @@ -22,9 +22,9 @@ ] EXTERNAL_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "z", "units": "dimensionless", "component": "my_algebraic_system"}, {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"}, - {"name": "z", "units": "dimensionless", "component": "my_algebraic_system"} + {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"} ] diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index e4406db8c..62255be3c 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -18,9 +18,9 @@ ] ALGEBRAIC_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "z", "units": "dimensionless", "component": "my_algebraic_system"}, {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"}, - {"name": "z", "units": "dimensionless", "component": "my_algebraic_system"} + {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"} ] @@ -48,9 +48,9 @@ def objective_function_0(u, f, data): algebraic[1] = u[1] algebraic[2] = u[2] - f[0] = 2.0*algebraic[0]+algebraic[1]-2.0*algebraic[2]-(-1.0) - f[1] = 3.0*algebraic[0]-3.0*algebraic[1]-algebraic[2]-5.0 - f[2] = algebraic[0]-2.0*algebraic[1]+3.0*algebraic[2]-6.0 + f[0] = 2.0*algebraic[2]+algebraic[1]-2.0*algebraic[0]-(-1.0) + f[1] = 3.0*algebraic[2]-3.0*algebraic[1]-algebraic[0]-5.0 + f[2] = algebraic[2]-2.0*algebraic[1]+3.0*algebraic[0]-6.0 def find_root_0(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index c1849c1a2..4807f0acd 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -13,8 +13,8 @@ const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 3; const VariableInfo CONSTANT_INFO[] = { - {"x", "dimensionless", "my_algebraic_system"}, - {"y", "dimensionless", "my_algebraic_system"} + {"y", "dimensionless", "my_algebraic_system"}, + {"x", "dimensionless", "my_algebraic_system"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { @@ -22,9 +22,9 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"d", "dimensionless", "my_algebraic_system"}, + {"c", "dimensionless", "my_algebraic_system"}, {"b", "dimensionless", "my_algebraic_system"}, - {"c", "dimensionless", "my_algebraic_system"} + {"d", "dimensionless", "my_algebraic_system"} }; double * createConstantsArray() @@ -80,11 +80,11 @@ void objectiveFunction0(double *u, double *f, void *data) double *computedConstants = ((RootFindingInfo *) data)->computedConstants; double *algebraic = ((RootFindingInfo *) data)->algebraic; - algebraic[2] = u[0]; + algebraic[0] = u[0]; algebraic[1] = u[1]; - f[0] = 3.0*computedConstants[0]+2.0*algebraic[1]+algebraic[2]-57.0; - f[1] = computedConstants[0]+3.0*algebraic[1]-algebraic[2]-19.0; + f[0] = 3.0*computedConstants[0]+2.0*algebraic[1]+algebraic[0]-57.0; + f[1] = computedConstants[0]+3.0*algebraic[1]-algebraic[0]-19.0; } void findRoot0(double *constants, double *computedConstants, double *algebraic) @@ -92,30 +92,30 @@ void findRoot0(double *constants, double *computedConstants, double *algebraic) RootFindingInfo rfi = { constants, computedConstants, algebraic }; double u[2]; - u[0] = algebraic[2]; + u[0] = algebraic[0]; u[1] = algebraic[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[2] = u[0]; + algebraic[0] = u[0]; algebraic[1] = u[1]; } void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { - constants[0] = 3.0; - constants[1] = 5.0; + constants[0] = 5.0; + constants[1] = 3.0; + algebraic[0] = 1.0; algebraic[1] = 1.0; - algebraic[2] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 3.0*constants[0]+constants[1]; + computedConstants[0] = 3.0*constants[1]+constants[0]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) { findRoot0(constants, computedConstants, algebraic); - algebraic[0] = algebraic[1]+algebraic[2]; + algebraic[2] = algebraic[1]+algebraic[0]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index e16b6b67b..44fb1e844 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -12,8 +12,8 @@ ALGEBRAIC_COUNT = 3 CONSTANT_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"}, - {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"} + {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"} ] COMPUTED_CONSTANT_INFO = [ @@ -21,9 +21,9 @@ ] ALGEBRAIC_INFO = [ - {"name": "d", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "c", "units": "dimensionless", "component": "my_algebraic_system"}, {"name": "b", "units": "dimensionless", "component": "my_algebraic_system"}, - {"name": "c", "units": "dimensionless", "component": "my_algebraic_system"} + {"name": "d", "units": "dimensionless", "component": "my_algebraic_system"} ] @@ -47,36 +47,36 @@ def objective_function_0(u, f, data): computed_constants = data[1] algebraic = data[2] - algebraic[2] = u[0] + algebraic[0] = u[0] algebraic[1] = u[1] - f[0] = 3.0*computed_constants[0]+2.0*algebraic[1]+algebraic[2]-57.0 - f[1] = computed_constants[0]+3.0*algebraic[1]-algebraic[2]-19.0 + f[0] = 3.0*computed_constants[0]+2.0*algebraic[1]+algebraic[0]-57.0 + f[1] = computed_constants[0]+3.0*algebraic[1]-algebraic[0]-19.0 def find_root_0(constants, computed_constants, algebraic): u = [nan]*2 - u[0] = algebraic[2] + u[0] = algebraic[0] u[1] = algebraic[1] u = nla_solve(objective_function_0, u, 2, [constants, computed_constants, algebraic]) - algebraic[2] = u[0] + algebraic[0] = u[0] algebraic[1] = u[1] def initialise_variables(constants, computed_constants, algebraic): - constants[0] = 3.0 - constants[1] = 5.0 + constants[0] = 5.0 + constants[1] = 3.0 + algebraic[0] = 1.0 algebraic[1] = 1.0 - algebraic[2] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 3.0*constants[0]+constants[1] + computed_constants[0] = 3.0*constants[1]+constants[0] def compute_variables(constants, computed_constants, algebraic): find_root_0(constants, computed_constants, algebraic) - algebraic[0] = algebraic[1]+algebraic[2] + algebraic[2] = algebraic[1]+algebraic[0] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index 3a27678bf..1c4a79701 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -13,8 +13,8 @@ const size_t COMPUTED_CONSTANT_COUNT = 1; const size_t ALGEBRAIC_COUNT = 3; const VariableInfo CONSTANT_INFO[] = { - {"x", "dimensionless", "my_algebraic_system"}, - {"y", "dimensionless", "my_algebraic_system"} + {"y", "dimensionless", "my_algebraic_system"}, + {"x", "dimensionless", "my_algebraic_system"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { @@ -103,15 +103,15 @@ void findRoot0(double *constants, double *computedConstants, double *algebraic) void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { - constants[0] = 3.0; - constants[1] = 5.0; + constants[0] = 5.0; + constants[1] = 3.0; algebraic[0] = 1.0; algebraic[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = 3.0*constants[0]+constants[1]; + computedConstants[0] = 3.0*constants[1]+constants[0]; } void computeVariables(double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 4bcd566de..44fb1e844 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -12,8 +12,8 @@ ALGEBRAIC_COUNT = 3 CONSTANT_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"}, - {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"} + {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"}, + {"name": "x", "units": "dimensionless", "component": "my_algebraic_system"} ] COMPUTED_CONSTANT_INFO = [ @@ -67,14 +67,14 @@ def find_root_0(constants, computed_constants, algebraic): def initialise_variables(constants, computed_constants, algebraic): - constants[0] = 3.0 - constants[1] = 5.0 + constants[0] = 5.0 + constants[1] = 3.0 algebraic[0] = 1.0 algebraic[1] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = 3.0*constants[0]+constants[1] + computed_constants[0] = 3.0*constants[1]+constants[0] def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index b96cc634e..a516d38f2 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -12,15 +12,15 @@ ALGEBRAIC_COUNT = 0 CONSTANT_INFO = [ - {"name": "E", "units": "fmol", "component": "SLC_template3_ss"}, - {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, + {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss"}, {"name": "q_Ao", "units": "fmol", "component": "SLC_template3_ss"}, - {"name": "P_1", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, {"name": "q_Ai", "units": "fmol", "component": "SLC_template3_ss"}, - {"name": "P_2", "units": "per_fmol_sec3", "component": "SLC_template3_ss"}, - {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss"}, {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss"}, - {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss"} + {"name": "P_3", "units": "per_fmol_sec3", "component": "SLC_template3_ss"}, + {"name": "P_2", "units": "per_fmol_sec3", "component": "SLC_template3_ss"}, + {"name": "P_1", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, + {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, + {"name": "E", "units": "fmol", "component": "SLC_template3_ss"} ] COMPUTED_CONSTANT_INFO = [ @@ -44,19 +44,19 @@ def create_algebraic_array(): def initialise_variables(constants, computed_constants, algebraic): - constants[0] = 1.1 - constants[1] = 21262500.0 - constants[2] = 150.0 - constants[3] = 3402000.0 - constants[4] = 2.0 + constants[0] = 810000.0 + constants[1] = 150.0 + constants[2] = 2.0 + constants[3] = 247140.0 + constants[4] = 2902500.0 constants[5] = 2902500.0 - constants[6] = 810000.0 - constants[7] = 247140.0 - constants[8] = 2902500.0 + constants[6] = 3402000.0 + constants[7] = 21262500.0 + constants[8] = 1.1 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+constants[8]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) + computed_constants[0] = constants[8]*(constants[7]*constants[1]-constants[6]*constants[2])/(constants[5]*constants[2]+constants[4]*constants[1]+constants[3]*constants[2]*constants[1]+constants[0]) def compute_variables(constants, computed_constants, algebraic): diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index b98629b5b..edb43ac18 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -34,9 +34,9 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { const VariableInfo ALGEBRAIC_INFO[] = { {"v_1", "C_per_s", "main"}, {"v_2", "C_per_s", "main"}, - {"u_1", "J_per_C", "main"}, + {"u_3", "J_per_C", "main"}, {"u_2", "J_per_C", "main"}, - {"u_3", "J_per_C", "main"} + {"u_1", "J_per_C", "main"} }; double * createStatesArray() @@ -135,9 +135,9 @@ void objectiveFunction1(double *u, double *f, void *data) double *computedConstants = ((RootFindingInfo *) data)->computedConstants; double *algebraic = ((RootFindingInfo *) data)->algebraic; - algebraic[4] = u[0]; + algebraic[2] = u[0]; - f[0] = algebraic[2]-(algebraic[3]+algebraic[4]); + f[0] = algebraic[4]-(algebraic[3]+algebraic[2]); } void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) @@ -145,11 +145,11 @@ void findRoot1(double voi, double *states, double *rates, double *constants, dou RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; double u[1]; - u[0] = algebraic[4]; + u[0] = algebraic[2]; nlaSolve(objectiveFunction1, u, 1, &rfi); - algebraic[4] = u[0]; + algebraic[2] = u[0]; } void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) @@ -162,7 +162,7 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[3] = 2.0; constants[4] = 10.0; algebraic[0] = 0.0; - algebraic[4] = 0.0; + algebraic[2] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -174,17 +174,17 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[1] = states[1]+constants[1]; findRoot0(voi, states, rates, constants, computedConstants, algebraic); rates[0] = algebraic[0]; - algebraic[2] = states[0]/constants[2]; algebraic[3] = constants[3]*algebraic[1]; + algebraic[4] = states[0]/constants[2]; findRoot1(voi, states, rates, constants, computedConstants, algebraic); - rates[1] = algebraic[4]/constants[4]; + rates[1] = algebraic[2]/constants[4]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { algebraic[1] = states[1]+constants[1]; findRoot0(voi, states, rates, constants, computedConstants, algebraic); - algebraic[2] = states[0]/constants[2]; algebraic[3] = constants[3]*algebraic[1]; + algebraic[4] = states[0]/constants[2]; findRoot1(voi, states, rates, constants, computedConstants, algebraic); } diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 9673c420a..d853a464d 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -33,9 +33,9 @@ ALGEBRAIC_INFO = [ {"name": "v_1", "units": "C_per_s", "component": "main"}, {"name": "v_2", "units": "C_per_s", "component": "main"}, - {"name": "u_1", "units": "J_per_C", "component": "main"}, + {"name": "u_3", "units": "J_per_C", "component": "main"}, {"name": "u_2", "units": "J_per_C", "component": "main"}, - {"name": "u_3", "units": "J_per_C", "component": "main"} + {"name": "u_1", "units": "J_per_C", "component": "main"} ] @@ -89,19 +89,19 @@ def objective_function_1(u, f, data): computed_constants = data[4] algebraic = data[5] - algebraic[4] = u[0] + algebraic[2] = u[0] - f[0] = algebraic[2]-(algebraic[3]+algebraic[4]) + f[0] = algebraic[4]-(algebraic[3]+algebraic[2]) def find_root_1(voi, states, rates, constants, computed_constants, algebraic): u = [nan]*1 - u[0] = algebraic[4] + u[0] = algebraic[2] u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) - algebraic[4] = u[0] + algebraic[2] = u[0] def initialise_variables(states, rates, constants, computed_constants, algebraic): @@ -113,7 +113,7 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic constants[3] = 2.0 constants[4] = 10.0 algebraic[0] = 0.0 - algebraic[4] = 0.0 + algebraic[2] = 0.0 def compute_computed_constants(constants, computed_constants): @@ -124,15 +124,15 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): algebraic[1] = states[1]+constants[1] find_root_0(voi, states, rates, constants, computed_constants, algebraic) rates[0] = algebraic[0] - algebraic[2] = states[0]/constants[2] algebraic[3] = constants[3]*algebraic[1] + algebraic[4] = states[0]/constants[2] find_root_1(voi, states, rates, constants, computed_constants, algebraic) - rates[1] = algebraic[4]/constants[4] + rates[1] = algebraic[2]/constants[4] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): algebraic[1] = states[1]+constants[1] find_root_0(voi, states, rates, constants, computed_constants, algebraic) - algebraic[2] = states[0]/constants[2] algebraic[3] = constants[3]*algebraic[1] + algebraic[4] = states[0]/constants[2] find_root_1(voi, states, rates, constants, computed_constants, algebraic) diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index a82fa83d6..57686b9e1 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -26,8 +26,8 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"a", "second", "my_component"}, - {"b", "second", "my_component"} + {"b", "second", "my_component"}, + {"a", "second", "my_component"} }; double * createStatesArray() @@ -95,6 +95,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[1] = 2.0*voi; - algebraic[0] = 3.0*algebraic[1]; + algebraic[0] = 2.0*voi; + algebraic[1] = 3.0*algebraic[0]; } diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index fc7bfc947..b51bbca56 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -25,8 +25,8 @@ ] ALGEBRAIC_INFO = [ - {"name": "a", "units": "second", "component": "my_component"}, - {"name": "b", "units": "second", "component": "my_component"} + {"name": "b", "units": "second", "component": "my_component"}, + {"name": "a", "units": "second", "component": "my_component"} ] @@ -59,5 +59,5 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = 2.0*voi - algebraic[0] = 3.0*algebraic[1] + algebraic[0] = 2.0*voi + algebraic[1] = 3.0*algebraic[0] diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 89ba9aa87..817aa3484 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -45,8 +45,8 @@ const VariableInfo STATE_INFO[] = { {"r", "dimensionless", "i_to_r_gate"}, {"q", "dimensionless", "i_to_q_gate"}, {"piy", "dimensionless", "i_Kr_pi_gate"}, - {"paF", "dimensionless", "i_Kr_pa_gate"}, {"paS", "dimensionless", "i_Kr_pa_gate"}, + {"paF", "dimensionless", "i_Kr_pa_gate"}, {"n", "dimensionless", "i_Ks_n_gate"}, {"a", "dimensionless", "i_KACh_a_gate"} }; @@ -55,53 +55,53 @@ const VariableInfo CONSTANT_INFO[] = { {"ACh", "millimolar", "Rate_modulation_experiments"}, {"Iso_1_uM", "dimensionless", "Rate_modulation_experiments"}, {"Nao", "millimolar", "Ionic_values"}, - {"Ko", "millimolar", "Ionic_values"}, {"Ki", "millimolar", "Ionic_values"}, + {"Ko", "millimolar", "Ionic_values"}, {"Cao", "millimolar", "Ionic_values"}, - {"Nai_clamp", "dimensionless", "Nai_concentration"}, {"F", "coulomb_per_mole", "Membrane"}, + {"Nai_clamp", "dimensionless", "Nai_concentration"}, {"Km_Nap", "millimolar", "i_NaK"}, {"Km_Kp", "millimolar", "i_NaK"}, {"i_NaK_max", "nanoA", "i_NaK"}, - {"blockade_NaCa", "dimensionless", "i_NaCa"}, {"K_NaCa", "nanoA", "i_NaCa"}, + {"blockade_NaCa", "dimensionless", "i_NaCa"}, {"K3ni", "millimolar", "i_NaCa"}, - {"Kci", "millimolar", "i_NaCa"}, {"Qci", "dimensionless", "i_NaCa"}, - {"K1ni", "millimolar", "i_NaCa"}, - {"K2ni", "millimolar", "i_NaCa"}, + {"Kci", "millimolar", "i_NaCa"}, {"Qn", "dimensionless", "i_NaCa"}, + {"K2ni", "millimolar", "i_NaCa"}, + {"K1ni", "millimolar", "i_NaCa"}, {"Kcni", "millimolar", "i_NaCa"}, {"K3no", "millimolar", "i_NaCa"}, - {"Kco", "millimolar", "i_NaCa"}, {"Qco", "dimensionless", "i_NaCa"}, - {"K1no", "millimolar", "i_NaCa"}, + {"Kco", "millimolar", "i_NaCa"}, {"K2no", "millimolar", "i_NaCa"}, + {"K1no", "millimolar", "i_NaCa"}, {"ks", "per_second", "Ca_SR_release"}, - {"MaxSR", "dimensionless", "Ca_SR_release"}, - {"MinSR", "dimensionless", "Ca_SR_release"}, - {"EC50_SR", "millimolar", "Ca_SR_release"}, {"HSR", "dimensionless", "Ca_SR_release"}, + {"EC50_SR", "millimolar", "Ca_SR_release"}, + {"MinSR", "dimensionless", "Ca_SR_release"}, + {"MaxSR", "dimensionless", "Ca_SR_release"}, {"koCa", "per_millimolar2_second", "Ca_SR_release"}, {"kiCa", "per_millimolar_second", "Ca_SR_release"}, - {"kim", "per_second", "Ca_SR_release"}, {"kom", "per_second", "Ca_SR_release"}, + {"kim", "per_second", "Ca_SR_release"}, {"P_up_basal", "millimolar_per_second", "Ca_intracellular_fluxes"}, {"tau_dif_Ca", "second", "Ca_intracellular_fluxes"}, - {"K_up", "millimolar", "Ca_intracellular_fluxes"}, {"slope_up", "millimolar", "Ca_intracellular_fluxes"}, + {"K_up", "millimolar", "Ca_intracellular_fluxes"}, {"tau_tr", "second", "Ca_intracellular_fluxes"}, - {"kf_TC", "per_millimolar_second", "Ca_buffering"}, {"kb_TC", "per_second", "Ca_buffering"}, - {"kf_TMC", "per_millimolar_second", "Ca_buffering"}, + {"kf_TC", "per_millimolar_second", "Ca_buffering"}, {"kb_TMC", "per_second", "Ca_buffering"}, - {"kf_TMM", "per_millimolar_second", "Ca_buffering"}, - {"Mgi", "millimolar", "Ca_buffering"}, + {"kf_TMC", "per_millimolar_second", "Ca_buffering"}, {"kb_TMM", "per_second", "Ca_buffering"}, - {"kf_CM", "per_millimolar_second", "Ca_buffering"}, + {"Mgi", "millimolar", "Ca_buffering"}, + {"kf_TMM", "per_millimolar_second", "Ca_buffering"}, {"kb_CM", "per_second", "Ca_buffering"}, - {"kf_CQ", "per_millimolar_second", "Ca_buffering"}, + {"kf_CM", "per_millimolar_second", "Ca_buffering"}, {"kb_CQ", "per_second", "Ca_buffering"}, + {"kf_CQ", "per_millimolar_second", "Ca_buffering"}, {"TC_tot", "millimolar", "Ca_buffering"}, {"TMC_tot", "millimolar", "Ca_buffering"}, {"CM_tot", "millimolar", "Ca_buffering"}, @@ -113,15 +113,15 @@ const VariableInfo CONSTANT_INFO[] = { {"V_i_part", "dimensionless", "Cell_parameters"}, {"V_nsr_part", "dimensionless", "Cell_parameters"}, {"C", "microF", "Membrane"}, - {"R", "joule_per_kilomole_kelvin", "Membrane"}, {"T", "kelvin", "Membrane"}, + {"R", "joule_per_kilomole_kelvin", "Membrane"}, {"clamp_mode", "dimensionless", "Membrane"}, {"V_test", "millivolt", "Voltage_clamp"}, - {"t_holding", "second", "Voltage_clamp"}, {"t_test", "second", "Voltage_clamp"}, + {"t_holding", "second", "Voltage_clamp"}, {"V_holding", "millivolt", "Voltage_clamp"}, - {"g_f", "microS", "i_f"}, {"Km_f", "millimolar", "i_f"}, + {"g_f", "microS", "i_f"}, {"alpha", "dimensionless", "i_f"}, {"blockade", "dimensionless", "i_f"}, {"y_shift", "millivolt", "i_f_y_gate"}, @@ -130,10 +130,10 @@ const VariableInfo CONSTANT_INFO[] = { {"delta_m", "millivolt", "i_Na_m_gate"}, {"g_Kur", "microS", "i_Kur"}, {"P_CaL", "nanoA_per_millimolar", "i_CaL"}, - {"V_dL", "millivolt", "i_CaL_dL_gate"}, {"k_dL", "millivolt", "i_CaL_dL_gate"}, - {"shift_fL", "millivolt", "i_CaL_fL_gate"}, + {"V_dL", "millivolt", "i_CaL_dL_gate"}, {"k_fL", "millivolt", "i_CaL_fL_gate"}, + {"shift_fL", "millivolt", "i_CaL_fL_gate"}, {"Km_fCa", "millimolar", "i_CaL_fCa_gate"}, {"alpha_fCa", "per_second", "i_CaL_fCa_gate"}, {"P_CaT", "nanoA_per_millimolar", "i_CaT"}, @@ -141,15 +141,15 @@ const VariableInfo CONSTANT_INFO[] = { {"g_to", "microS", "i_to"}, {"g_Kr", "microS", "i_Kr"}, {"g_Ks_", "microS", "i_Ks"}, - {"ACh_on", "dimensionless", "i_KACh"}, - {"g_KACh", "microS", "i_KACh"} + {"g_KACh", "microS", "i_KACh"}, + {"ACh_on", "dimensionless", "i_KACh"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { {"RTONF", "millivolt", "Membrane"}, {"E_K", "millivolt", "Ionic_values"}, - {"V_i", "millimetre3", "Cell_parameters"}, {"V_sub", "millimetre3", "Cell_parameters"}, + {"V_i", "millimetre3", "Cell_parameters"}, {"Iso_increase", "dimensionless", "i_NaK"}, {"k34", "dimensionless", "i_NaCa"}, {"b_up", "dimensionless", "Ca_intracellular_fluxes"}, @@ -174,25 +174,25 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"E_Na", "millivolt", "Ionic_values"}, {"Nai", "millimolar", "Nai_concentration"}, + {"E_Na", "millivolt", "Ionic_values"}, {"E_Ca", "millivolt", "Ionic_values"}, - {"i_Na", "nanoA", "i_Na"}, {"i_NaCa", "nanoA", "i_NaCa"}, {"i_NaK", "nanoA", "i_NaK"}, {"i_siNa", "nanoA", "i_CaL"}, {"i_fNa", "nanoA", "i_f"}, + {"i_Na", "nanoA", "i_Na"}, {"V", "millivolt", "Membrane"}, + {"x4", "dimensionless", "i_NaCa"}, + {"x3", "dimensionless", "i_NaCa"}, {"x2", "dimensionless", "i_NaCa"}, - {"k21", "dimensionless", "i_NaCa"}, {"x1", "dimensionless", "i_NaCa"}, {"k12", "dimensionless", "i_NaCa"}, - {"x4", "dimensionless", "i_NaCa"}, - {"x3", "dimensionless", "i_NaCa"}, + {"k21", "dimensionless", "i_NaCa"}, {"k41", "dimensionless", "i_NaCa"}, - {"k23", "dimensionless", "i_NaCa"}, {"k43", "dimensionless", "i_NaCa"}, {"k32", "dimensionless", "i_NaCa"}, + {"k23", "dimensionless", "i_NaCa"}, {"k14", "dimensionless", "i_NaCa"}, {"di", "dimensionless", "i_NaCa"}, {"do", "dimensionless", "i_NaCa"}, @@ -211,16 +211,16 @@ const VariableInfo ALGEBRAIC_INFO[] = { {"delta_fCMi", "per_second", "Ca_buffering"}, {"delta_fCMs", "per_second", "Ca_buffering"}, {"delta_fCQ", "per_second", "Ca_buffering"}, - {"i_siCa", "nanoA", "i_CaL"}, {"i_CaT", "nanoA", "i_CaT"}, - {"i_tot", "nanoA", "Membrane"}, - {"i_f", "nanoA", "i_f"}, + {"i_siCa", "nanoA", "i_CaL"}, {"i_Kur", "nanoA", "i_Kur"}, {"i_KACh", "nanoA", "i_KACh"}, {"i_CaL", "nanoA", "i_CaL"}, {"i_to", "nanoA", "i_to"}, {"i_Ks", "nanoA", "i_Ks"}, {"i_Kr", "nanoA", "i_Kr"}, + {"i_f", "nanoA", "i_f"}, + {"i_tot", "nanoA", "Membrane"}, {"V_clamp", "millivolt", "Voltage_clamp"}, {"i_fK", "nanoA", "i_f"}, {"tau_y", "second", "i_f_y_gate"}, @@ -237,15 +237,15 @@ const VariableInfo ALGEBRAIC_INFO[] = { {"alpha_h", "per_second", "i_Na_h_gate"}, {"beta_h", "per_second", "i_Na_h_gate"}, {"tau_h", "second", "i_Na_h_gate"}, - {"r_Kur_infinity", "dimensionless", "i_Kur_rKur_gate"}, {"tau_r_Kur", "second", "i_Kur_rKur_gate"}, - {"s_Kur_infinity", "dimensionless", "i_Kur_sKur_gate"}, + {"r_Kur_infinity", "dimensionless", "i_Kur_rKur_gate"}, {"tau_s_Kur", "second", "i_Kur_sKur_gate"}, + {"s_Kur_infinity", "dimensionless", "i_Kur_sKur_gate"}, {"i_siK", "nanoA", "i_CaL"}, {"dL_infinity", "dimensionless", "i_CaL_dL_gate"}, - {"tau_dL", "second", "i_CaL_dL_gate"}, - {"alpha_dL", "per_second", "i_CaL_dL_gate"}, {"beta_dL", "per_second", "i_CaL_dL_gate"}, + {"alpha_dL", "per_second", "i_CaL_dL_gate"}, + {"tau_dL", "second", "i_CaL_dL_gate"}, {"adVm", "millivolt", "i_CaL_dL_gate"}, {"bdVm", "millivolt", "i_CaL_dL_gate"}, {"fL_infinity", "dimensionless", "i_CaL_fL_gate"}, @@ -269,9 +269,9 @@ const VariableInfo ALGEBRAIC_INFO[] = { {"pi_infinity", "dimensionless", "i_Kr_pi_gate"}, {"E_Ks", "millivolt", "i_Ks"}, {"n_infinity", "dimensionless", "i_Ks_n_gate"}, - {"tau_n", "second", "i_Ks_n_gate"}, - {"alpha_n", "per_second", "i_Ks_n_gate"}, {"beta_n", "per_second", "i_Ks_n_gate"}, + {"alpha_n", "per_second", "i_Ks_n_gate"}, + {"tau_n", "second", "i_Ks_n_gate"}, {"beta_a", "per_second", "i_KACh_a_gate"}, {"a_infinity", "dimensionless", "i_KACh_a_gate"}, {"tau_a", "second", "i_KACh_a_gate"} @@ -357,60 +357,60 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl states[26] = 0.014523; states[27] = 0.430836; states[28] = 0.709051; - states[29] = 0.011068; - states[30] = 0.283185; + states[29] = 0.283185; + states[30] = 0.011068; states[31] = 0.1162; states[32] = 0.00277; constants[0] = 0.0; constants[1] = 0.0; constants[2] = 140.0; - constants[3] = 5.4; - constants[4] = 140.0; + constants[3] = 140.0; + constants[4] = 5.4; constants[5] = 1.8; - constants[6] = 1.0; - constants[7] = 96485.3415; + constants[6] = 96485.3415; + constants[7] = 1.0; constants[8] = 14.0; constants[9] = 1.4; constants[10] = 0.08105; - constants[11] = 0.0; - constants[12] = 3.343; + constants[11] = 3.343; + constants[12] = 0.0; constants[13] = 26.44; - constants[14] = 0.0207; - constants[15] = 0.1369; - constants[16] = 395.3; + constants[14] = 0.1369; + constants[15] = 0.0207; + constants[16] = 0.4315; constants[17] = 2.289; - constants[18] = 0.4315; + constants[18] = 395.3; constants[19] = 26.44; constants[20] = 4.663; - constants[21] = 3.663; - constants[22] = 0.0; - constants[23] = 1628.0; - constants[24] = 561.4; + constants[21] = 0.0; + constants[22] = 3.663; + constants[23] = 561.4; + constants[24] = 1628.0; constants[25] = 148041085.1; - constants[26] = 15.0; - constants[27] = 1.0; - constants[28] = 0.45; - constants[29] = 2.5; + constants[26] = 2.5; + constants[27] = 0.45; + constants[28] = 1.0; + constants[29] = 15.0; constants[30] = 10000.0; constants[31] = 500.0; - constants[32] = 5.0; - constants[33] = 660.0; + constants[32] = 660.0; + constants[33] = 5.0; constants[34] = 5.0; constants[35] = 5.469e-5; - constants[36] = 0.000286113; - constants[37] = 5.0e-5; + constants[36] = 5.0e-5; + constants[37] = 0.000286113; constants[38] = 0.04; - constants[39] = 88800.0; - constants[40] = 446.0; - constants[41] = 227700.0; - constants[42] = 7.51; - constants[43] = 2277.0; + constants[39] = 446.0; + constants[40] = 88800.0; + constants[41] = 7.51; + constants[42] = 227700.0; + constants[43] = 751.0; constants[44] = 2.5; - constants[45] = 751.0; - constants[46] = 1.642e6; - constants[47] = 542.0; - constants[48] = 175.4; - constants[49] = 445.0; + constants[45] = 2277.0; + constants[46] = 542.0; + constants[47] = 1.642e6; + constants[48] = 445.0; + constants[49] = 175.4; constants[50] = 0.031; constants[51] = 0.062; constants[52] = 0.045; @@ -422,15 +422,15 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[58] = 0.46; constants[59] = 0.0116; constants[60] = 5.7e-5; - constants[61] = 8314.472; - constants[62] = 310.0; + constants[61] = 310.0; + constants[62] = 8314.472; constants[63] = 0.0; constants[64] = -35.0; constants[65] = 0.5; constants[66] = 0.5; constants[67] = -45.0; - constants[68] = 0.00427; - constants[69] = 45.0; + constants[68] = 45.0; + constants[69] = 0.00427; constants[70] = 0.5927; constants[71] = 0.0; constants[72] = 0.0; @@ -439,8 +439,8 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[75] = 1.0e-5; constants[76] = 0.1539e-3; constants[77] = 0.4578; - constants[78] = -16.4508; - constants[79] = 4.3371; + constants[78] = 4.3371; + constants[79] = -16.4508; constants[80] = 0.0; constants[81] = 0.0; constants[82] = 0.000338; @@ -450,28 +450,28 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[86] = 3.5e-3; constants[87] = 0.00424; constants[88] = 0.00065; - constants[89] = 1.0; - constants[90] = 0.00345; + constants[89] = 0.00345; + constants[90] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { - computedConstants[0] = constants[61]*constants[62]/constants[7]; - computedConstants[1] = computedConstants[0]*log(constants[3]/constants[4]); + computedConstants[0] = constants[62]*constants[61]/constants[6]; + computedConstants[1] = computedConstants[0]*log(constants[4]/constants[3]); computedConstants[4] = (constants[1] > 0.0)?1.2:1.0; computedConstants[5] = constants[2]/(constants[20]+constants[2]); computedConstants[6] = (constants[1] > 0.0)?-0.25:(constants[0] > 0.0)?0.7*constants[0]/(0.00009+constants[0]):0.0; computedConstants[7] = constants[34]*(1.0-computedConstants[6]); computedConstants[10] = 0.000000001*3.14159265358979*pow(constants[55], 2.0)*constants[54]; - computedConstants[3] = 0.000000001*2.0*3.14159265358979*constants[56]*(constants[55]-constants[56]/2.0)*constants[54]; + computedConstants[2] = 0.000000001*2.0*3.14159265358979*constants[56]*(constants[55]-constants[56]/2.0)*constants[54]; computedConstants[9] = constants[57]*computedConstants[10]; - computedConstants[2] = constants[58]*computedConstants[10]-computedConstants[3]; + computedConstants[3] = constants[58]*computedConstants[10]-computedConstants[2]; computedConstants[8] = constants[59]*computedConstants[10]; - computedConstants[11] = constants[68]/(constants[3]/(constants[3]+constants[69])); + computedConstants[11] = constants[69]/(constants[4]/(constants[4]+constants[68])); computedConstants[12] = computedConstants[11]/(constants[70]+1.0); computedConstants[13] = constants[70]*computedConstants[12]; - computedConstants[14] = computedConstants[13]*constants[3]/(constants[3]+constants[69]); - computedConstants[15] = computedConstants[12]*constants[3]/(constants[3]+constants[69]); + computedConstants[14] = computedConstants[13]*constants[4]/(constants[4]+constants[68]); + computedConstants[15] = computedConstants[12]*constants[4]/(constants[4]+constants[68]); computedConstants[16] = (constants[0] > 0.0)?-1.0-9.898*pow(1.0*constants[0], 0.618)/(pow(1.0*constants[0], 0.618)+0.00122423):0.0; computedConstants[17] = (constants[1] > 0.0)?7.5:0.0; computedConstants[18] = (constants[1] > 0.0)?1.23:1.0; @@ -485,192 +485,192 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[1] = states[1]; - algebraic[51] = computedConstants[0]*log((constants[2]+0.12*constants[3])/(algebraic[1]+0.12*constants[4])); - algebraic[47] = ((voi > constants[65]) && (voi < constants[65]+constants[66]))?constants[64]:constants[67]; + algebraic[0] = states[1]; + algebraic[47] = ((voi > constants[66]) && (voi < constants[66]+constants[65]))?constants[64]:constants[67]; algebraic[8] = (constants[63] >= 1.0)?algebraic[47]:states[15]; - algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]); + algebraic[5] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(algebraic[0]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraic[1] = computedConstants[0]*log(constants[2]/algebraic[0]); + algebraic[6] = states[16]*computedConstants[14]*(algebraic[8]-algebraic[1])*(1.0-constants[71]); + algebraic[51] = computedConstants[0]*log((constants[2]+0.12*constants[4])/(algebraic[0]+0.12*constants[3])); algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]); - algebraic[3] = algebraic[52]+algebraic[53]; - algebraic[6] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(algebraic[1]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraic[0] = computedConstants[0]*log(constants[2]/algebraic[1]); - algebraic[7] = states[16]*computedConstants[14]*(algebraic[8]-algebraic[0])*(1.0-constants[71]); - algebraic[5] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[3], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[1], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[0]+110.0)/20.0), -1.0); - algebraic[21] = 1.0+constants[5]/constants[21]*(1.0+exp(constants[22]*algebraic[8]/computedConstants[0]))+constants[2]/constants[23]*(1.0+constants[2]/constants[24]*(1.0+constants[2]/constants[20])); - algebraic[10] = constants[5]/constants[21]*exp(constants[22]*algebraic[8]/computedConstants[0])/algebraic[21]; - algebraic[20] = 1.0+states[0]/constants[14]*(1.0+exp(-constants[15]*algebraic[8]/computedConstants[0])+algebraic[1]/constants[19])+algebraic[1]/constants[16]*(1.0+algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])); - algebraic[12] = states[0]/constants[14]*exp(-constants[15]*algebraic[8]/computedConstants[0])/algebraic[20]; - algebraic[17] = algebraic[1]/(constants[13]+algebraic[1]); - algebraic[18] = exp(constants[18]*algebraic[8]/(2.0*computedConstants[0])); - algebraic[15] = exp(-constants[18]*algebraic[8]/(2.0*computedConstants[0])); - algebraic[19] = algebraic[1]/constants[16]*algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])*exp(constants[18]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[20]; - algebraic[9] = algebraic[18]*algebraic[17]*(algebraic[19]+algebraic[12])+algebraic[15]*algebraic[12]*(computedConstants[5]+algebraic[18]); - algebraic[16] = constants[2]/constants[23]*constants[2]/constants[24]*(1.0+constants[2]/constants[20])*exp(-constants[18]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[21]; - algebraic[11] = algebraic[15]*computedConstants[5]*(algebraic[16]+algebraic[10])+algebraic[10]*algebraic[18]*(algebraic[17]+algebraic[15]); - algebraic[13] = algebraic[16]*computedConstants[5]*(algebraic[19]+algebraic[12])+algebraic[19]*algebraic[10]*(computedConstants[5]+algebraic[18]); - algebraic[14] = algebraic[19]*algebraic[17]*(algebraic[16]+algebraic[10])+algebraic[12]*algebraic[16]*(algebraic[17]+algebraic[15]); - algebraic[4] = (1.0-constants[11])*constants[12]*(algebraic[9]*algebraic[10]-algebraic[11]*algebraic[12])/(algebraic[11]+algebraic[9]+algebraic[14]+algebraic[13]); - rates[1] = (1.0-constants[6])*-1.0*(algebraic[3]+algebraic[7]+algebraic[6]+3.0*algebraic[5]+3.0*algebraic[4])/(1.0*(computedConstants[2]+computedConstants[3])*constants[7]); - algebraic[24] = constants[26]-(constants[26]-constants[27])/(1.0+pow(constants[28]/states[2], constants[29])); - algebraic[26] = constants[31]*algebraic[24]; + algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]); + algebraic[7] = algebraic[52]+algebraic[53]; + algebraic[4] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[0], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[1]+110.0)/20.0), -1.0); + algebraic[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic[8]/computedConstants[0])+algebraic[0]/constants[19])+algebraic[0]/constants[18]*(1.0+algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])); + algebraic[13] = states[0]/constants[15]*exp(-constants[14]*algebraic[8]/computedConstants[0])/algebraic[20]; + algebraic[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraic[8]/computedConstants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])); + algebraic[14] = constants[5]/constants[22]*exp(constants[21]*algebraic[8]/computedConstants[0])/algebraic[21]; + algebraic[17] = exp(constants[16]*algebraic[8]/(2.0*computedConstants[0])); + algebraic[19] = algebraic[0]/constants[18]*algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])*exp(constants[16]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[20]; + algebraic[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[21]; + algebraic[9] = algebraic[18]*computedConstants[5]*(algebraic[19]+algebraic[13])+algebraic[19]*algebraic[14]*(computedConstants[5]+algebraic[17]); + algebraic[16] = algebraic[0]/(constants[13]+algebraic[0]); + algebraic[15] = exp(-constants[16]*algebraic[8]/(2.0*computedConstants[0])); + algebraic[10] = algebraic[19]*algebraic[16]*(algebraic[18]+algebraic[14])+algebraic[13]*algebraic[18]*(algebraic[16]+algebraic[15]); + algebraic[11] = algebraic[17]*algebraic[16]*(algebraic[19]+algebraic[13])+algebraic[15]*algebraic[13]*(computedConstants[5]+algebraic[17]); + algebraic[12] = algebraic[15]*computedConstants[5]*(algebraic[18]+algebraic[14])+algebraic[14]*algebraic[17]*(algebraic[16]+algebraic[15]); + algebraic[3] = (1.0-constants[12])*constants[11]*(algebraic[11]*algebraic[14]-algebraic[12]*algebraic[13])/(algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]); + rates[1] = (1.0-constants[7])*-1.0*(algebraic[7]+algebraic[6]+algebraic[5]+3.0*algebraic[4]+3.0*algebraic[3])/(1.0*(computedConstants[3]+computedConstants[2])*constants[6]); + algebraic[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])); algebraic[25] = constants[30]/algebraic[24]; - rates[4] = constants[32]*states[5]-algebraic[26]*states[0]*states[4]-(algebraic[25]*pow(states[0], 2.0)*states[4]-constants[33]*states[3]); - rates[3] = algebraic[25]*pow(states[0], 2.0)*states[4]-constants[33]*states[3]-(algebraic[26]*states[0]*states[3]-constants[32]*states[6]); - rates[6] = algebraic[26]*states[0]*states[3]-constants[32]*states[6]-(constants[33]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]); - rates[5] = constants[33]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]-(constants[32]*states[5]-algebraic[26]*states[0]*states[4]); - algebraic[31] = constants[39]*states[7]*(1.0-states[9])-constants[40]*states[9]; + algebraic[26] = constants[31]*algebraic[24]; + rates[4] = constants[33]*states[5]-algebraic[26]*states[0]*states[4]-(algebraic[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]); + rates[3] = algebraic[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]-(algebraic[26]*states[0]*states[3]-constants[33]*states[6]); + rates[6] = algebraic[26]*states[0]*states[3]-constants[33]*states[6]-(constants[32]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]); + rates[5] = constants[32]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]-(constants[33]*states[5]-algebraic[26]*states[0]*states[4]); + algebraic[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9]; rates[9] = algebraic[31]; - algebraic[32] = constants[41]*states[7]*(1.0-(states[10]+states[11]))-constants[42]*states[10]; + algebraic[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10]; rates[10] = algebraic[32]; - algebraic[33] = constants[43]*constants[44]*(1.0-(states[10]+states[11]))-constants[45]*states[11]; + algebraic[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11]; rates[11] = algebraic[33]; - algebraic[34] = constants[46]*states[7]*(1.0-states[12])-constants[47]*states[12]; + algebraic[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12]; rates[12] = algebraic[34]; - algebraic[35] = constants[46]*states[0]*(1.0-states[13])-constants[47]*states[13]; + algebraic[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13]; rates[13] = algebraic[35]; - algebraic[36] = constants[48]*states[2]*(1.0-states[14])-constants[49]*states[14]; + algebraic[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14]; rates[14] = algebraic[36]; + algebraic[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])); algebraic[28] = (states[0]-states[7])/constants[35]; - algebraic[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[36])/constants[37])); - rates[7] = 1.0*(algebraic[28]*computedConstants[3]-algebraic[29]*computedConstants[8])/computedConstants[2]-(constants[52]*algebraic[34]+constants[50]*algebraic[31]+constants[51]*algebraic[32]); + rates[7] = 1.0*(algebraic[28]*computedConstants[2]-algebraic[29]*computedConstants[8])/computedConstants[3]-(constants[52]*algebraic[34]+constants[50]*algebraic[31]+constants[51]*algebraic[32]); algebraic[22] = constants[25]*states[3]*(states[2]-states[0]); - algebraic[37] = 2.0*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraic[38] = 2.0*constants[84]*algebraic[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computedConstants[0]))*states[25]*states[24]; - rates[0] = algebraic[22]*computedConstants[9]/computedConstants[3]-((algebraic[37]+algebraic[38]-2.0*algebraic[4])/(2.0*constants[7]*computedConstants[3])+algebraic[28]+constants[52]*algebraic[35]); + algebraic[37] = 2.0*constants[84]*algebraic[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computedConstants[0]))*states[25]*states[24]; + algebraic[38] = 2.0*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + rates[0] = algebraic[22]*computedConstants[9]/computedConstants[2]-((algebraic[38]+algebraic[37]-2.0*algebraic[3])/(2.0*constants[6]*computedConstants[2])+algebraic[28]+constants[52]*algebraic[35]); algebraic[30] = (states[8]-states[2])/constants[38]; rates[8] = algebraic[29]-algebraic[30]*computedConstants[9]/computedConstants[8]; rates[2] = algebraic[30]-(algebraic[22]+constants[53]*algebraic[36]); + algebraic[39] = constants[76]*states[20]*states[19]*(algebraic[8]-computedConstants[1]); + algebraic[40] = (constants[0] > 0.0)?constants[90]*constants[89]*(algebraic[8]-computedConstants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32]:0.0; + algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraic[41] = (algebraic[38]+algebraic[67]+algebraic[5])*(1.0-computedConstants[19])*1.0*computedConstants[18]; + algebraic[42] = constants[86]*(algebraic[8]-computedConstants[1])*states[27]*states[26]; + algebraic[93] = computedConstants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraic[0])); + algebraic[43] = computedConstants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0); + algebraic[44] = constants[87]*(algebraic[8]-computedConstants[1])*(0.9*states[30]+0.1*states[29])*states[28]; algebraic[48] = states[16]*computedConstants[15]*(algebraic[8]-computedConstants[1])*(1.0-constants[71]); - algebraic[40] = algebraic[7]+algebraic[48]; - algebraic[41] = constants[76]*states[20]*states[19]*(algebraic[8]-computedConstants[1]); - algebraic[42] = (constants[0] > 0.0)?constants[89]*constants[90]*(algebraic[8]-computedConstants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32]:0.0; - algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(constants[4]-constants[3]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraic[43] = (algebraic[37]+algebraic[67]+algebraic[6])*(1.0-computedConstants[19])*1.0*computedConstants[18]; - algebraic[44] = constants[86]*(algebraic[8]-computedConstants[1])*states[27]*states[26]; - algebraic[93] = computedConstants[0]*log((constants[3]+0.12*constants[2])/(constants[4]+0.12*algebraic[1])); - algebraic[45] = computedConstants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0); - algebraic[46] = constants[87]*(algebraic[8]-computedConstants[1])*(0.9*states[29]+0.1*states[30])*states[28]; - algebraic[39] = algebraic[40]+algebraic[46]+algebraic[45]+algebraic[44]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[43]+algebraic[38]+algebraic[42]+algebraic[41]; - rates[15] = -algebraic[39]/constants[60]; - algebraic[50] = (algebraic[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraic[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); + algebraic[45] = algebraic[6]+algebraic[48]; + algebraic[46] = algebraic[45]+algebraic[44]+algebraic[43]+algebraic[42]+algebraic[4]+algebraic[3]+algebraic[7]+algebraic[41]+algebraic[37]+algebraic[40]+algebraic[39]; + rates[15] = -algebraic[46]/constants[60]; algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17])/(exp(0.066*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17]))-1.0)+0.1*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17]))))-0.054; + algebraic[50] = (algebraic[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraic[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); rates[16] = (algebraic[50]-states[16])/algebraic[49]; - algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)); + algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)); algebraic[55] = algebraic[8]+41.0; algebraic[56] = (fabs(algebraic[55]) < constants[75])?2000.0:200.0*algebraic[55]/(1.0-exp(-0.1*algebraic[55])); - algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)); algebraic[58] = 1.0/(algebraic[56]+algebraic[57]); + algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)); rates[18] = (algebraic[54]-states[18])/algebraic[58]; - algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)); - algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)); algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0); + algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)); algebraic[62] = 1.0/(algebraic[60]+algebraic[61]); + algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)); rates[17] = (algebraic[59]-states[17])/algebraic[62]; - algebraic[63] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)); - algebraic[64] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005; - rates[20] = (algebraic[63]-states[20])/algebraic[64]; - algebraic[65] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)); - algebraic[66] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05; - rates[19] = (algebraic[65]-states[19])/algebraic[66]; - algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[78]-computedConstants[20])/(constants[79]*(1.0+computedConstants[21]/100.0)))); + algebraic[63] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005; + algebraic[64] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)); + rates[20] = (algebraic[64]-states[20])/algebraic[63]; + algebraic[65] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05; + algebraic[66] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)); + rates[19] = (algebraic[66]-states[19])/algebraic[65]; + algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[79]-computedConstants[20])/(constants[78]*(1.0+computedConstants[21]/100.0)))); + algebraic[73] = (algebraic[8] == -1.8)?-1.80001:algebraic[8]; + algebraic[69] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0); algebraic[72] = (algebraic[8] == -41.8)?-41.80001:(algebraic[8] == 0.0)?0.0:(algebraic[8] == -6.8)?-6.80001:algebraic[8]; algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0); - algebraic[73] = (algebraic[8] == -1.8)?-1.80001:algebraic[8]; - algebraic[71] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0); - algebraic[69] = 0.001/(algebraic[70]+algebraic[71]); - rates[23] = (algebraic[68]-states[23])/algebraic[69]; - algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[80])/(5.3+constants[81]))); + algebraic[71] = 0.001/(algebraic[70]+algebraic[69]); + rates[23] = (algebraic[68]-states[23])/algebraic[71]; algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))); + algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[81])/(5.3+constants[80]))); rates[22] = (algebraic[74]-states[22])/algebraic[75]; algebraic[76] = constants[82]/(constants[82]+states[0]); algebraic[77] = 0.001*algebraic[76]/constants[83]; rates[21] = (algebraic[76]-states[21])/algebraic[77]; - algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)); algebraic[79] = 0.001/(1.068*exp((algebraic[8]+38.3)/30.0)+1.068*exp(-(algebraic[8]+38.3)/30.0)); + algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)); rates[25] = (algebraic[78]-states[25])/algebraic[79]; - algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)); algebraic[81] = 1.0/(16.67*exp(-(algebraic[8]+75.0)/83.3)+16.67*exp((algebraic[8]+75.0)/15.38))+constants[85]; + algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)); rates[24] = (algebraic[80]-states[24])/algebraic[81]; - algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)); algebraic[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[8]+44.0))+0.065*exp(0.1*(algebraic[8]+45.93)))+10.1); + algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)); rates[27] = (algebraic[82]-states[27])/algebraic[83]; - algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)); algebraic[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[8]+30.61))+0.369*exp(-0.12*(algebraic[8]+23.84)))+2.98); + algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)); rates[26] = (algebraic[84]-states[26])/algebraic[85]; - algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)); algebraic[89] = 0.84655354/(4.2*exp(algebraic[8]/17.0)+0.15*exp(-algebraic[8]/21.6)); - rates[30] = (algebraic[88]-states[30])/algebraic[89]; + algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)); + rates[29] = (algebraic[88]-states[29])/algebraic[89]; algebraic[90] = 1.0/(30.0*exp(algebraic[8]/10.0)+exp(-algebraic[8]/12.0)); - rates[29] = (algebraic[88]-states[29])/algebraic[90]; - algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)); + rates[30] = (algebraic[88]-states[30])/algebraic[90]; algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)); + algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)); rates[28] = (algebraic[92]-states[28])/algebraic[91]; algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computedConstants[23])/10.7071))); + algebraic[95] = 1.0*exp(-(algebraic[8]-computedConstants[23]-5.0)/25.0); algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computedConstants[23])/3.0)); - algebraic[97] = 1.0*exp(-(algebraic[8]-computedConstants[23]-5.0)/25.0); - algebraic[95] = 1.0/(algebraic[96]+algebraic[97]); - rates[31] = (algebraic[94]-states[31])/algebraic[95]; + algebraic[97] = 1.0/(algebraic[96]+algebraic[95]); + rates[31] = (algebraic[94]-states[31])/algebraic[97]; algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)); - algebraic[99] = computedConstants[24]/(computedConstants[24]+algebraic[98]); algebraic[100] = 1.0/(computedConstants[24]+algebraic[98]); + algebraic[99] = computedConstants[24]/(computedConstants[24]+algebraic[98]); rates[32] = (algebraic[99]-states[32])/algebraic[100]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[1] = states[1]; - algebraic[0] = computedConstants[0]*log(constants[2]/algebraic[1]); + algebraic[0] = states[1]; + algebraic[1] = computedConstants[0]*log(constants[2]/algebraic[0]); algebraic[2] = 0.5*computedConstants[0]*log(constants[5]/states[0]); algebraic[8] = (constants[63] >= 1.0)?algebraic[47]:states[15]; - algebraic[5] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[3], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[1], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[0]+110.0)/20.0), -1.0); - algebraic[21] = 1.0+constants[5]/constants[21]*(1.0+exp(constants[22]*algebraic[8]/computedConstants[0]))+constants[2]/constants[23]*(1.0+constants[2]/constants[24]*(1.0+constants[2]/constants[20])); - algebraic[10] = constants[5]/constants[21]*exp(constants[22]*algebraic[8]/computedConstants[0])/algebraic[21]; - algebraic[20] = 1.0+states[0]/constants[14]*(1.0+exp(-constants[15]*algebraic[8]/computedConstants[0])+algebraic[1]/constants[19])+algebraic[1]/constants[16]*(1.0+algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])); - algebraic[12] = states[0]/constants[14]*exp(-constants[15]*algebraic[8]/computedConstants[0])/algebraic[20]; - algebraic[17] = algebraic[1]/(constants[13]+algebraic[1]); - algebraic[18] = exp(constants[18]*algebraic[8]/(2.0*computedConstants[0])); - algebraic[15] = exp(-constants[18]*algebraic[8]/(2.0*computedConstants[0])); - algebraic[19] = algebraic[1]/constants[16]*algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])*exp(constants[18]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[20]; - algebraic[9] = algebraic[18]*algebraic[17]*(algebraic[19]+algebraic[12])+algebraic[15]*algebraic[12]*(computedConstants[5]+algebraic[18]); - algebraic[16] = constants[2]/constants[23]*constants[2]/constants[24]*(1.0+constants[2]/constants[20])*exp(-constants[18]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[21]; - algebraic[11] = algebraic[15]*computedConstants[5]*(algebraic[16]+algebraic[10])+algebraic[10]*algebraic[18]*(algebraic[17]+algebraic[15]); - algebraic[13] = algebraic[16]*computedConstants[5]*(algebraic[19]+algebraic[12])+algebraic[19]*algebraic[10]*(computedConstants[5]+algebraic[18]); - algebraic[14] = algebraic[19]*algebraic[17]*(algebraic[16]+algebraic[10])+algebraic[12]*algebraic[16]*(algebraic[17]+algebraic[15]); - algebraic[4] = (1.0-constants[11])*constants[12]*(algebraic[9]*algebraic[10]-algebraic[11]*algebraic[12])/(algebraic[11]+algebraic[9]+algebraic[14]+algebraic[13]); + algebraic[4] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[0], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[1]+110.0)/20.0), -1.0); + algebraic[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic[8]/computedConstants[0])+algebraic[0]/constants[19])+algebraic[0]/constants[18]*(1.0+algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])); + algebraic[13] = states[0]/constants[15]*exp(-constants[14]*algebraic[8]/computedConstants[0])/algebraic[20]; + algebraic[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraic[8]/computedConstants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])); + algebraic[14] = constants[5]/constants[22]*exp(constants[21]*algebraic[8]/computedConstants[0])/algebraic[21]; + algebraic[17] = exp(constants[16]*algebraic[8]/(2.0*computedConstants[0])); + algebraic[19] = algebraic[0]/constants[18]*algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])*exp(constants[16]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[20]; + algebraic[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[21]; + algebraic[9] = algebraic[18]*computedConstants[5]*(algebraic[19]+algebraic[13])+algebraic[19]*algebraic[14]*(computedConstants[5]+algebraic[17]); + algebraic[16] = algebraic[0]/(constants[13]+algebraic[0]); + algebraic[15] = exp(-constants[16]*algebraic[8]/(2.0*computedConstants[0])); + algebraic[10] = algebraic[19]*algebraic[16]*(algebraic[18]+algebraic[14])+algebraic[13]*algebraic[18]*(algebraic[16]+algebraic[15]); + algebraic[11] = algebraic[17]*algebraic[16]*(algebraic[19]+algebraic[13])+algebraic[15]*algebraic[13]*(computedConstants[5]+algebraic[17]); + algebraic[12] = algebraic[15]*computedConstants[5]*(algebraic[18]+algebraic[14])+algebraic[14]*algebraic[17]*(algebraic[16]+algebraic[15]); + algebraic[3] = (1.0-constants[12])*constants[11]*(algebraic[11]*algebraic[14]-algebraic[12]*algebraic[13])/(algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]); algebraic[22] = constants[25]*states[3]*(states[2]-states[0]); algebraic[23] = states[2]-states[0]; - algebraic[24] = constants[26]-(constants[26]-constants[27])/(1.0+pow(constants[28]/states[2], constants[29])); + algebraic[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])); algebraic[25] = constants[30]/algebraic[24]; algebraic[26] = constants[31]*algebraic[24]; algebraic[27] = states[4]+states[3]+states[6]+states[5]; algebraic[28] = (states[0]-states[7])/constants[35]; - algebraic[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[36])/constants[37])); + algebraic[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])); algebraic[30] = (states[8]-states[2])/constants[38]; - algebraic[31] = constants[39]*states[7]*(1.0-states[9])-constants[40]*states[9]; - algebraic[32] = constants[41]*states[7]*(1.0-(states[10]+states[11]))-constants[42]*states[10]; - algebraic[33] = constants[43]*constants[44]*(1.0-(states[10]+states[11]))-constants[45]*states[11]; - algebraic[34] = constants[46]*states[7]*(1.0-states[12])-constants[47]*states[12]; - algebraic[35] = constants[46]*states[0]*(1.0-states[13])-constants[47]*states[13]; - algebraic[36] = constants[48]*states[2]*(1.0-states[14])-constants[49]*states[14]; - algebraic[7] = states[16]*computedConstants[14]*(algebraic[8]-algebraic[0])*(1.0-constants[71]); - algebraic[48] = states[16]*computedConstants[15]*(algebraic[8]-computedConstants[1])*(1.0-constants[71]); - algebraic[40] = algebraic[7]+algebraic[48]; - algebraic[41] = constants[76]*states[20]*states[19]*(algebraic[8]-computedConstants[1]); - algebraic[42] = (constants[0] > 0.0)?constants[89]*constants[90]*(algebraic[8]-computedConstants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32]:0.0; - algebraic[38] = 2.0*constants[84]*algebraic[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computedConstants[0]))*states[25]*states[24]; - algebraic[37] = 2.0*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraic[6] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(algebraic[1]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(constants[4]-constants[3]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraic[43] = (algebraic[37]+algebraic[67]+algebraic[6])*(1.0-computedConstants[19])*1.0*computedConstants[18]; - algebraic[51] = computedConstants[0]*log((constants[2]+0.12*constants[3])/(algebraic[1]+0.12*constants[4])); - algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]); + algebraic[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9]; + algebraic[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10]; + algebraic[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11]; + algebraic[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12]; + algebraic[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13]; + algebraic[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14]; + algebraic[39] = constants[76]*states[20]*states[19]*(algebraic[8]-computedConstants[1]); + algebraic[40] = (constants[0] > 0.0)?constants[90]*constants[89]*(algebraic[8]-computedConstants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32]:0.0; + algebraic[37] = 2.0*constants[84]*algebraic[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computedConstants[0]))*states[25]*states[24]; + algebraic[5] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(algebraic[0]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraic[38] = 2.0*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraic[41] = (algebraic[38]+algebraic[67]+algebraic[5])*(1.0-computedConstants[19])*1.0*computedConstants[18]; + algebraic[51] = computedConstants[0]*log((constants[2]+0.12*constants[4])/(algebraic[0]+0.12*constants[3])); algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]); - algebraic[3] = algebraic[52]+algebraic[53]; - algebraic[44] = constants[86]*(algebraic[8]-computedConstants[1])*states[27]*states[26]; - algebraic[93] = computedConstants[0]*log((constants[3]+0.12*constants[2])/(constants[4]+0.12*algebraic[1])); - algebraic[45] = computedConstants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0); - algebraic[46] = constants[87]*(algebraic[8]-computedConstants[1])*(0.9*states[29]+0.1*states[30])*states[28]; - algebraic[39] = algebraic[40]+algebraic[46]+algebraic[45]+algebraic[44]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[43]+algebraic[38]+algebraic[42]+algebraic[41]; + algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]); + algebraic[7] = algebraic[52]+algebraic[53]; + algebraic[42] = constants[86]*(algebraic[8]-computedConstants[1])*states[27]*states[26]; + algebraic[93] = computedConstants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraic[0])); + algebraic[43] = computedConstants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0); + algebraic[44] = constants[87]*(algebraic[8]-computedConstants[1])*(0.9*states[30]+0.1*states[29])*states[28]; + algebraic[48] = states[16]*computedConstants[15]*(algebraic[8]-computedConstants[1])*(1.0-constants[71]); + algebraic[6] = states[16]*computedConstants[14]*(algebraic[8]-algebraic[1])*(1.0-constants[71]); + algebraic[45] = algebraic[6]+algebraic[48]; + algebraic[46] = algebraic[45]+algebraic[44]+algebraic[43]+algebraic[42]+algebraic[4]+algebraic[3]+algebraic[7]+algebraic[41]+algebraic[37]+algebraic[40]+algebraic[39]; algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17])/(exp(0.066*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17]))-1.0)+0.1*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17]))))-0.054; algebraic[50] = (algebraic[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraic[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)); @@ -682,17 +682,17 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)); algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0); algebraic[62] = 1.0/(algebraic[60]+algebraic[61]); - algebraic[63] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)); - algebraic[64] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005; - algebraic[65] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)); - algebraic[66] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05; - algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[78]-computedConstants[20])/(constants[79]*(1.0+computedConstants[21]/100.0)))); + algebraic[64] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)); + algebraic[63] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005; + algebraic[66] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)); + algebraic[65] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05; + algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[79]-computedConstants[20])/(constants[78]*(1.0+computedConstants[21]/100.0)))); + algebraic[73] = (algebraic[8] == -1.8)?-1.80001:algebraic[8]; + algebraic[69] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0); algebraic[72] = (algebraic[8] == -41.8)?-41.80001:(algebraic[8] == 0.0)?0.0:(algebraic[8] == -6.8)?-6.80001:algebraic[8]; algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0); - algebraic[73] = (algebraic[8] == -1.8)?-1.80001:algebraic[8]; - algebraic[71] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0); - algebraic[69] = 0.001/(algebraic[70]+algebraic[71]); - algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[80])/(5.3+constants[81]))); + algebraic[71] = 0.001/(algebraic[70]+algebraic[69]); + algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[81])/(5.3+constants[80]))); algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))); algebraic[76] = constants[82]/(constants[82]+states[0]); algebraic[77] = 0.001*algebraic[76]/constants[83]; @@ -712,9 +712,9 @@ void computeVariables(double voi, double *states, double *rates, double *constan algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)); algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)); algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computedConstants[23])/10.7071))); + algebraic[95] = 1.0*exp(-(algebraic[8]-computedConstants[23]-5.0)/25.0); algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computedConstants[23])/3.0)); - algebraic[97] = 1.0*exp(-(algebraic[8]-computedConstants[23]-5.0)/25.0); - algebraic[95] = 1.0/(algebraic[96]+algebraic[97]); + algebraic[97] = 1.0/(algebraic[96]+algebraic[95]); algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)); algebraic[99] = computedConstants[24]/(computedConstants[24]+algebraic[98]); algebraic[100] = 1.0/(computedConstants[24]+algebraic[98]); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index efa8e06b7..fd0ce8784 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -44,8 +44,8 @@ {"name": "r", "units": "dimensionless", "component": "i_to_r_gate"}, {"name": "q", "units": "dimensionless", "component": "i_to_q_gate"}, {"name": "piy", "units": "dimensionless", "component": "i_Kr_pi_gate"}, - {"name": "paF", "units": "dimensionless", "component": "i_Kr_pa_gate"}, {"name": "paS", "units": "dimensionless", "component": "i_Kr_pa_gate"}, + {"name": "paF", "units": "dimensionless", "component": "i_Kr_pa_gate"}, {"name": "n", "units": "dimensionless", "component": "i_Ks_n_gate"}, {"name": "a", "units": "dimensionless", "component": "i_KACh_a_gate"} ] @@ -54,53 +54,53 @@ {"name": "ACh", "units": "millimolar", "component": "Rate_modulation_experiments"}, {"name": "Iso_1_uM", "units": "dimensionless", "component": "Rate_modulation_experiments"}, {"name": "Nao", "units": "millimolar", "component": "Ionic_values"}, - {"name": "Ko", "units": "millimolar", "component": "Ionic_values"}, {"name": "Ki", "units": "millimolar", "component": "Ionic_values"}, + {"name": "Ko", "units": "millimolar", "component": "Ionic_values"}, {"name": "Cao", "units": "millimolar", "component": "Ionic_values"}, - {"name": "Nai_clamp", "units": "dimensionless", "component": "Nai_concentration"}, {"name": "F", "units": "coulomb_per_mole", "component": "Membrane"}, + {"name": "Nai_clamp", "units": "dimensionless", "component": "Nai_concentration"}, {"name": "Km_Nap", "units": "millimolar", "component": "i_NaK"}, {"name": "Km_Kp", "units": "millimolar", "component": "i_NaK"}, {"name": "i_NaK_max", "units": "nanoA", "component": "i_NaK"}, - {"name": "blockade_NaCa", "units": "dimensionless", "component": "i_NaCa"}, {"name": "K_NaCa", "units": "nanoA", "component": "i_NaCa"}, + {"name": "blockade_NaCa", "units": "dimensionless", "component": "i_NaCa"}, {"name": "K3ni", "units": "millimolar", "component": "i_NaCa"}, - {"name": "Kci", "units": "millimolar", "component": "i_NaCa"}, {"name": "Qci", "units": "dimensionless", "component": "i_NaCa"}, - {"name": "K1ni", "units": "millimolar", "component": "i_NaCa"}, - {"name": "K2ni", "units": "millimolar", "component": "i_NaCa"}, + {"name": "Kci", "units": "millimolar", "component": "i_NaCa"}, {"name": "Qn", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "K2ni", "units": "millimolar", "component": "i_NaCa"}, + {"name": "K1ni", "units": "millimolar", "component": "i_NaCa"}, {"name": "Kcni", "units": "millimolar", "component": "i_NaCa"}, {"name": "K3no", "units": "millimolar", "component": "i_NaCa"}, - {"name": "Kco", "units": "millimolar", "component": "i_NaCa"}, {"name": "Qco", "units": "dimensionless", "component": "i_NaCa"}, - {"name": "K1no", "units": "millimolar", "component": "i_NaCa"}, + {"name": "Kco", "units": "millimolar", "component": "i_NaCa"}, {"name": "K2no", "units": "millimolar", "component": "i_NaCa"}, + {"name": "K1no", "units": "millimolar", "component": "i_NaCa"}, {"name": "ks", "units": "per_second", "component": "Ca_SR_release"}, - {"name": "MaxSR", "units": "dimensionless", "component": "Ca_SR_release"}, - {"name": "MinSR", "units": "dimensionless", "component": "Ca_SR_release"}, - {"name": "EC50_SR", "units": "millimolar", "component": "Ca_SR_release"}, {"name": "HSR", "units": "dimensionless", "component": "Ca_SR_release"}, + {"name": "EC50_SR", "units": "millimolar", "component": "Ca_SR_release"}, + {"name": "MinSR", "units": "dimensionless", "component": "Ca_SR_release"}, + {"name": "MaxSR", "units": "dimensionless", "component": "Ca_SR_release"}, {"name": "koCa", "units": "per_millimolar2_second", "component": "Ca_SR_release"}, {"name": "kiCa", "units": "per_millimolar_second", "component": "Ca_SR_release"}, - {"name": "kim", "units": "per_second", "component": "Ca_SR_release"}, {"name": "kom", "units": "per_second", "component": "Ca_SR_release"}, + {"name": "kim", "units": "per_second", "component": "Ca_SR_release"}, {"name": "P_up_basal", "units": "millimolar_per_second", "component": "Ca_intracellular_fluxes"}, {"name": "tau_dif_Ca", "units": "second", "component": "Ca_intracellular_fluxes"}, - {"name": "K_up", "units": "millimolar", "component": "Ca_intracellular_fluxes"}, {"name": "slope_up", "units": "millimolar", "component": "Ca_intracellular_fluxes"}, + {"name": "K_up", "units": "millimolar", "component": "Ca_intracellular_fluxes"}, {"name": "tau_tr", "units": "second", "component": "Ca_intracellular_fluxes"}, - {"name": "kf_TC", "units": "per_millimolar_second", "component": "Ca_buffering"}, {"name": "kb_TC", "units": "per_second", "component": "Ca_buffering"}, - {"name": "kf_TMC", "units": "per_millimolar_second", "component": "Ca_buffering"}, + {"name": "kf_TC", "units": "per_millimolar_second", "component": "Ca_buffering"}, {"name": "kb_TMC", "units": "per_second", "component": "Ca_buffering"}, - {"name": "kf_TMM", "units": "per_millimolar_second", "component": "Ca_buffering"}, - {"name": "Mgi", "units": "millimolar", "component": "Ca_buffering"}, + {"name": "kf_TMC", "units": "per_millimolar_second", "component": "Ca_buffering"}, {"name": "kb_TMM", "units": "per_second", "component": "Ca_buffering"}, - {"name": "kf_CM", "units": "per_millimolar_second", "component": "Ca_buffering"}, + {"name": "Mgi", "units": "millimolar", "component": "Ca_buffering"}, + {"name": "kf_TMM", "units": "per_millimolar_second", "component": "Ca_buffering"}, {"name": "kb_CM", "units": "per_second", "component": "Ca_buffering"}, - {"name": "kf_CQ", "units": "per_millimolar_second", "component": "Ca_buffering"}, + {"name": "kf_CM", "units": "per_millimolar_second", "component": "Ca_buffering"}, {"name": "kb_CQ", "units": "per_second", "component": "Ca_buffering"}, + {"name": "kf_CQ", "units": "per_millimolar_second", "component": "Ca_buffering"}, {"name": "TC_tot", "units": "millimolar", "component": "Ca_buffering"}, {"name": "TMC_tot", "units": "millimolar", "component": "Ca_buffering"}, {"name": "CM_tot", "units": "millimolar", "component": "Ca_buffering"}, @@ -112,15 +112,15 @@ {"name": "V_i_part", "units": "dimensionless", "component": "Cell_parameters"}, {"name": "V_nsr_part", "units": "dimensionless", "component": "Cell_parameters"}, {"name": "C", "units": "microF", "component": "Membrane"}, - {"name": "R", "units": "joule_per_kilomole_kelvin", "component": "Membrane"}, {"name": "T", "units": "kelvin", "component": "Membrane"}, + {"name": "R", "units": "joule_per_kilomole_kelvin", "component": "Membrane"}, {"name": "clamp_mode", "units": "dimensionless", "component": "Membrane"}, {"name": "V_test", "units": "millivolt", "component": "Voltage_clamp"}, - {"name": "t_holding", "units": "second", "component": "Voltage_clamp"}, {"name": "t_test", "units": "second", "component": "Voltage_clamp"}, + {"name": "t_holding", "units": "second", "component": "Voltage_clamp"}, {"name": "V_holding", "units": "millivolt", "component": "Voltage_clamp"}, - {"name": "g_f", "units": "microS", "component": "i_f"}, {"name": "Km_f", "units": "millimolar", "component": "i_f"}, + {"name": "g_f", "units": "microS", "component": "i_f"}, {"name": "alpha", "units": "dimensionless", "component": "i_f"}, {"name": "blockade", "units": "dimensionless", "component": "i_f"}, {"name": "y_shift", "units": "millivolt", "component": "i_f_y_gate"}, @@ -129,10 +129,10 @@ {"name": "delta_m", "units": "millivolt", "component": "i_Na_m_gate"}, {"name": "g_Kur", "units": "microS", "component": "i_Kur"}, {"name": "P_CaL", "units": "nanoA_per_millimolar", "component": "i_CaL"}, - {"name": "V_dL", "units": "millivolt", "component": "i_CaL_dL_gate"}, {"name": "k_dL", "units": "millivolt", "component": "i_CaL_dL_gate"}, - {"name": "shift_fL", "units": "millivolt", "component": "i_CaL_fL_gate"}, + {"name": "V_dL", "units": "millivolt", "component": "i_CaL_dL_gate"}, {"name": "k_fL", "units": "millivolt", "component": "i_CaL_fL_gate"}, + {"name": "shift_fL", "units": "millivolt", "component": "i_CaL_fL_gate"}, {"name": "Km_fCa", "units": "millimolar", "component": "i_CaL_fCa_gate"}, {"name": "alpha_fCa", "units": "per_second", "component": "i_CaL_fCa_gate"}, {"name": "P_CaT", "units": "nanoA_per_millimolar", "component": "i_CaT"}, @@ -140,15 +140,15 @@ {"name": "g_to", "units": "microS", "component": "i_to"}, {"name": "g_Kr", "units": "microS", "component": "i_Kr"}, {"name": "g_Ks_", "units": "microS", "component": "i_Ks"}, - {"name": "ACh_on", "units": "dimensionless", "component": "i_KACh"}, - {"name": "g_KACh", "units": "microS", "component": "i_KACh"} + {"name": "g_KACh", "units": "microS", "component": "i_KACh"}, + {"name": "ACh_on", "units": "dimensionless", "component": "i_KACh"} ] COMPUTED_CONSTANT_INFO = [ {"name": "RTONF", "units": "millivolt", "component": "Membrane"}, {"name": "E_K", "units": "millivolt", "component": "Ionic_values"}, - {"name": "V_i", "units": "millimetre3", "component": "Cell_parameters"}, {"name": "V_sub", "units": "millimetre3", "component": "Cell_parameters"}, + {"name": "V_i", "units": "millimetre3", "component": "Cell_parameters"}, {"name": "Iso_increase", "units": "dimensionless", "component": "i_NaK"}, {"name": "k34", "units": "dimensionless", "component": "i_NaCa"}, {"name": "b_up", "units": "dimensionless", "component": "Ca_intracellular_fluxes"}, @@ -173,25 +173,25 @@ ] ALGEBRAIC_INFO = [ - {"name": "E_Na", "units": "millivolt", "component": "Ionic_values"}, {"name": "Nai", "units": "millimolar", "component": "Nai_concentration"}, + {"name": "E_Na", "units": "millivolt", "component": "Ionic_values"}, {"name": "E_Ca", "units": "millivolt", "component": "Ionic_values"}, - {"name": "i_Na", "units": "nanoA", "component": "i_Na"}, {"name": "i_NaCa", "units": "nanoA", "component": "i_NaCa"}, {"name": "i_NaK", "units": "nanoA", "component": "i_NaK"}, {"name": "i_siNa", "units": "nanoA", "component": "i_CaL"}, {"name": "i_fNa", "units": "nanoA", "component": "i_f"}, + {"name": "i_Na", "units": "nanoA", "component": "i_Na"}, {"name": "V", "units": "millivolt", "component": "Membrane"}, + {"name": "x4", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "x3", "units": "dimensionless", "component": "i_NaCa"}, {"name": "x2", "units": "dimensionless", "component": "i_NaCa"}, - {"name": "k21", "units": "dimensionless", "component": "i_NaCa"}, {"name": "x1", "units": "dimensionless", "component": "i_NaCa"}, {"name": "k12", "units": "dimensionless", "component": "i_NaCa"}, - {"name": "x4", "units": "dimensionless", "component": "i_NaCa"}, - {"name": "x3", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "k21", "units": "dimensionless", "component": "i_NaCa"}, {"name": "k41", "units": "dimensionless", "component": "i_NaCa"}, - {"name": "k23", "units": "dimensionless", "component": "i_NaCa"}, {"name": "k43", "units": "dimensionless", "component": "i_NaCa"}, {"name": "k32", "units": "dimensionless", "component": "i_NaCa"}, + {"name": "k23", "units": "dimensionless", "component": "i_NaCa"}, {"name": "k14", "units": "dimensionless", "component": "i_NaCa"}, {"name": "di", "units": "dimensionless", "component": "i_NaCa"}, {"name": "do", "units": "dimensionless", "component": "i_NaCa"}, @@ -210,16 +210,16 @@ {"name": "delta_fCMi", "units": "per_second", "component": "Ca_buffering"}, {"name": "delta_fCMs", "units": "per_second", "component": "Ca_buffering"}, {"name": "delta_fCQ", "units": "per_second", "component": "Ca_buffering"}, - {"name": "i_siCa", "units": "nanoA", "component": "i_CaL"}, {"name": "i_CaT", "units": "nanoA", "component": "i_CaT"}, - {"name": "i_tot", "units": "nanoA", "component": "Membrane"}, - {"name": "i_f", "units": "nanoA", "component": "i_f"}, + {"name": "i_siCa", "units": "nanoA", "component": "i_CaL"}, {"name": "i_Kur", "units": "nanoA", "component": "i_Kur"}, {"name": "i_KACh", "units": "nanoA", "component": "i_KACh"}, {"name": "i_CaL", "units": "nanoA", "component": "i_CaL"}, {"name": "i_to", "units": "nanoA", "component": "i_to"}, {"name": "i_Ks", "units": "nanoA", "component": "i_Ks"}, {"name": "i_Kr", "units": "nanoA", "component": "i_Kr"}, + {"name": "i_f", "units": "nanoA", "component": "i_f"}, + {"name": "i_tot", "units": "nanoA", "component": "Membrane"}, {"name": "V_clamp", "units": "millivolt", "component": "Voltage_clamp"}, {"name": "i_fK", "units": "nanoA", "component": "i_f"}, {"name": "tau_y", "units": "second", "component": "i_f_y_gate"}, @@ -236,15 +236,15 @@ {"name": "alpha_h", "units": "per_second", "component": "i_Na_h_gate"}, {"name": "beta_h", "units": "per_second", "component": "i_Na_h_gate"}, {"name": "tau_h", "units": "second", "component": "i_Na_h_gate"}, - {"name": "r_Kur_infinity", "units": "dimensionless", "component": "i_Kur_rKur_gate"}, {"name": "tau_r_Kur", "units": "second", "component": "i_Kur_rKur_gate"}, - {"name": "s_Kur_infinity", "units": "dimensionless", "component": "i_Kur_sKur_gate"}, + {"name": "r_Kur_infinity", "units": "dimensionless", "component": "i_Kur_rKur_gate"}, {"name": "tau_s_Kur", "units": "second", "component": "i_Kur_sKur_gate"}, + {"name": "s_Kur_infinity", "units": "dimensionless", "component": "i_Kur_sKur_gate"}, {"name": "i_siK", "units": "nanoA", "component": "i_CaL"}, {"name": "dL_infinity", "units": "dimensionless", "component": "i_CaL_dL_gate"}, - {"name": "tau_dL", "units": "second", "component": "i_CaL_dL_gate"}, - {"name": "alpha_dL", "units": "per_second", "component": "i_CaL_dL_gate"}, {"name": "beta_dL", "units": "per_second", "component": "i_CaL_dL_gate"}, + {"name": "alpha_dL", "units": "per_second", "component": "i_CaL_dL_gate"}, + {"name": "tau_dL", "units": "second", "component": "i_CaL_dL_gate"}, {"name": "adVm", "units": "millivolt", "component": "i_CaL_dL_gate"}, {"name": "bdVm", "units": "millivolt", "component": "i_CaL_dL_gate"}, {"name": "fL_infinity", "units": "dimensionless", "component": "i_CaL_fL_gate"}, @@ -268,9 +268,9 @@ {"name": "pi_infinity", "units": "dimensionless", "component": "i_Kr_pi_gate"}, {"name": "E_Ks", "units": "millivolt", "component": "i_Ks"}, {"name": "n_infinity", "units": "dimensionless", "component": "i_Ks_n_gate"}, - {"name": "tau_n", "units": "second", "component": "i_Ks_n_gate"}, - {"name": "alpha_n", "units": "per_second", "component": "i_Ks_n_gate"}, {"name": "beta_n", "units": "per_second", "component": "i_Ks_n_gate"}, + {"name": "alpha_n", "units": "per_second", "component": "i_Ks_n_gate"}, + {"name": "tau_n", "units": "second", "component": "i_Ks_n_gate"}, {"name": "beta_a", "units": "per_second", "component": "i_KACh_a_gate"}, {"name": "a_infinity", "units": "dimensionless", "component": "i_KACh_a_gate"}, {"name": "tau_a", "units": "second", "component": "i_KACh_a_gate"} @@ -343,60 +343,60 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic states[26] = 0.014523 states[27] = 0.430836 states[28] = 0.709051 - states[29] = 0.011068 - states[30] = 0.283185 + states[29] = 0.283185 + states[30] = 0.011068 states[31] = 0.1162 states[32] = 0.00277 constants[0] = 0.0 constants[1] = 0.0 constants[2] = 140.0 - constants[3] = 5.4 - constants[4] = 140.0 + constants[3] = 140.0 + constants[4] = 5.4 constants[5] = 1.8 - constants[6] = 1.0 - constants[7] = 96485.3415 + constants[6] = 96485.3415 + constants[7] = 1.0 constants[8] = 14.0 constants[9] = 1.4 constants[10] = 0.08105 - constants[11] = 0.0 - constants[12] = 3.343 + constants[11] = 3.343 + constants[12] = 0.0 constants[13] = 26.44 - constants[14] = 0.0207 - constants[15] = 0.1369 - constants[16] = 395.3 + constants[14] = 0.1369 + constants[15] = 0.0207 + constants[16] = 0.4315 constants[17] = 2.289 - constants[18] = 0.4315 + constants[18] = 395.3 constants[19] = 26.44 constants[20] = 4.663 - constants[21] = 3.663 - constants[22] = 0.0 - constants[23] = 1628.0 - constants[24] = 561.4 + constants[21] = 0.0 + constants[22] = 3.663 + constants[23] = 561.4 + constants[24] = 1628.0 constants[25] = 148041085.1 - constants[26] = 15.0 - constants[27] = 1.0 - constants[28] = 0.45 - constants[29] = 2.5 + constants[26] = 2.5 + constants[27] = 0.45 + constants[28] = 1.0 + constants[29] = 15.0 constants[30] = 10000.0 constants[31] = 500.0 - constants[32] = 5.0 - constants[33] = 660.0 + constants[32] = 660.0 + constants[33] = 5.0 constants[34] = 5.0 constants[35] = 5.469e-5 - constants[36] = 0.000286113 - constants[37] = 5.0e-5 + constants[36] = 5.0e-5 + constants[37] = 0.000286113 constants[38] = 0.04 - constants[39] = 88800.0 - constants[40] = 446.0 - constants[41] = 227700.0 - constants[42] = 7.51 - constants[43] = 2277.0 + constants[39] = 446.0 + constants[40] = 88800.0 + constants[41] = 7.51 + constants[42] = 227700.0 + constants[43] = 751.0 constants[44] = 2.5 - constants[45] = 751.0 - constants[46] = 1.642e6 - constants[47] = 542.0 - constants[48] = 175.4 - constants[49] = 445.0 + constants[45] = 2277.0 + constants[46] = 542.0 + constants[47] = 1.642e6 + constants[48] = 445.0 + constants[49] = 175.4 constants[50] = 0.031 constants[51] = 0.062 constants[52] = 0.045 @@ -408,15 +408,15 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic constants[58] = 0.46 constants[59] = 0.0116 constants[60] = 5.7e-5 - constants[61] = 8314.472 - constants[62] = 310.0 + constants[61] = 310.0 + constants[62] = 8314.472 constants[63] = 0.0 constants[64] = -35.0 constants[65] = 0.5 constants[66] = 0.5 constants[67] = -45.0 - constants[68] = 0.00427 - constants[69] = 45.0 + constants[68] = 45.0 + constants[69] = 0.00427 constants[70] = 0.5927 constants[71] = 0.0 constants[72] = 0.0 @@ -425,8 +425,8 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic constants[75] = 1.0e-5 constants[76] = 0.1539e-3 constants[77] = 0.4578 - constants[78] = -16.4508 - constants[79] = 4.3371 + constants[78] = 4.3371 + constants[79] = -16.4508 constants[80] = 0.0 constants[81] = 0.0 constants[82] = 0.000338 @@ -436,27 +436,27 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic constants[86] = 3.5e-3 constants[87] = 0.00424 constants[88] = 0.00065 - constants[89] = 1.0 - constants[90] = 0.00345 + constants[89] = 0.00345 + constants[90] = 1.0 def compute_computed_constants(constants, computed_constants): - computed_constants[0] = constants[61]*constants[62]/constants[7] - computed_constants[1] = computed_constants[0]*log(constants[3]/constants[4]) + computed_constants[0] = constants[62]*constants[61]/constants[6] + computed_constants[1] = computed_constants[0]*log(constants[4]/constants[3]) computed_constants[4] = 1.2 if gt_func(constants[1], 0.0) else 1.0 computed_constants[5] = constants[2]/(constants[20]+constants[2]) computed_constants[6] = -0.25 if gt_func(constants[1], 0.0) else 0.7*constants[0]/(0.00009+constants[0]) if gt_func(constants[0], 0.0) else 0.0 computed_constants[7] = constants[34]*(1.0-computed_constants[6]) computed_constants[10] = 0.000000001*3.14159265358979*pow(constants[55], 2.0)*constants[54] - computed_constants[3] = 0.000000001*2.0*3.14159265358979*constants[56]*(constants[55]-constants[56]/2.0)*constants[54] + computed_constants[2] = 0.000000001*2.0*3.14159265358979*constants[56]*(constants[55]-constants[56]/2.0)*constants[54] computed_constants[9] = constants[57]*computed_constants[10] - computed_constants[2] = constants[58]*computed_constants[10]-computed_constants[3] + computed_constants[3] = constants[58]*computed_constants[10]-computed_constants[2] computed_constants[8] = constants[59]*computed_constants[10] - computed_constants[11] = constants[68]/(constants[3]/(constants[3]+constants[69])) + computed_constants[11] = constants[69]/(constants[4]/(constants[4]+constants[68])) computed_constants[12] = computed_constants[11]/(constants[70]+1.0) computed_constants[13] = constants[70]*computed_constants[12] - computed_constants[14] = computed_constants[13]*constants[3]/(constants[3]+constants[69]) - computed_constants[15] = computed_constants[12]*constants[3]/(constants[3]+constants[69]) + computed_constants[14] = computed_constants[13]*constants[4]/(constants[4]+constants[68]) + computed_constants[15] = computed_constants[12]*constants[4]/(constants[4]+constants[68]) computed_constants[16] = -1.0-9.898*pow(1.0*constants[0], 0.618)/(pow(1.0*constants[0], 0.618)+0.00122423) if gt_func(constants[0], 0.0) else 0.0 computed_constants[17] = 7.5 if gt_func(constants[1], 0.0) else 0.0 computed_constants[18] = 1.23 if gt_func(constants[1], 0.0) else 1.0 @@ -469,191 +469,191 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = states[1] - algebraic[51] = computed_constants[0]*log((constants[2]+0.12*constants[3])/(algebraic[1]+0.12*constants[4])) - algebraic[47] = constants[64] if and_func(gt_func(voi, constants[65]), lt_func(voi, constants[65]+constants[66])) else constants[67] + algebraic[0] = states[1] + algebraic[47] = constants[64] if and_func(gt_func(voi, constants[66]), lt_func(voi, constants[66]+constants[65])) else constants[67] algebraic[8] = algebraic[47] if geq_func(constants[63], 1.0) else states[15] - algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]) + algebraic[5] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(algebraic[0]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic[1] = computed_constants[0]*log(constants[2]/algebraic[0]) + algebraic[6] = states[16]*computed_constants[14]*(algebraic[8]-algebraic[1])*(1.0-constants[71]) + algebraic[51] = computed_constants[0]*log((constants[2]+0.12*constants[4])/(algebraic[0]+0.12*constants[3])) algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]) - algebraic[3] = algebraic[52]+algebraic[53] - algebraic[6] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(algebraic[1]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic[0] = computed_constants[0]*log(constants[2]/algebraic[1]) - algebraic[7] = states[16]*computed_constants[14]*(algebraic[8]-algebraic[0])*(1.0-constants[71]) - algebraic[5] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[3], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[1], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[0]+110.0)/20.0), -1.0) - algebraic[21] = 1.0+constants[5]/constants[21]*(1.0+exp(constants[22]*algebraic[8]/computed_constants[0]))+constants[2]/constants[23]*(1.0+constants[2]/constants[24]*(1.0+constants[2]/constants[20])) - algebraic[10] = constants[5]/constants[21]*exp(constants[22]*algebraic[8]/computed_constants[0])/algebraic[21] - algebraic[20] = 1.0+states[0]/constants[14]*(1.0+exp(-constants[15]*algebraic[8]/computed_constants[0])+algebraic[1]/constants[19])+algebraic[1]/constants[16]*(1.0+algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])) - algebraic[12] = states[0]/constants[14]*exp(-constants[15]*algebraic[8]/computed_constants[0])/algebraic[20] - algebraic[17] = algebraic[1]/(constants[13]+algebraic[1]) - algebraic[18] = exp(constants[18]*algebraic[8]/(2.0*computed_constants[0])) - algebraic[15] = exp(-constants[18]*algebraic[8]/(2.0*computed_constants[0])) - algebraic[19] = algebraic[1]/constants[16]*algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])*exp(constants[18]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[20] - algebraic[9] = algebraic[18]*algebraic[17]*(algebraic[19]+algebraic[12])+algebraic[15]*algebraic[12]*(computed_constants[5]+algebraic[18]) - algebraic[16] = constants[2]/constants[23]*constants[2]/constants[24]*(1.0+constants[2]/constants[20])*exp(-constants[18]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[21] - algebraic[11] = algebraic[15]*computed_constants[5]*(algebraic[16]+algebraic[10])+algebraic[10]*algebraic[18]*(algebraic[17]+algebraic[15]) - algebraic[13] = algebraic[16]*computed_constants[5]*(algebraic[19]+algebraic[12])+algebraic[19]*algebraic[10]*(computed_constants[5]+algebraic[18]) - algebraic[14] = algebraic[19]*algebraic[17]*(algebraic[16]+algebraic[10])+algebraic[12]*algebraic[16]*(algebraic[17]+algebraic[15]) - algebraic[4] = (1.0-constants[11])*constants[12]*(algebraic[9]*algebraic[10]-algebraic[11]*algebraic[12])/(algebraic[11]+algebraic[9]+algebraic[14]+algebraic[13]) - rates[1] = (1.0-constants[6])*-1.0*(algebraic[3]+algebraic[7]+algebraic[6]+3.0*algebraic[5]+3.0*algebraic[4])/(1.0*(computed_constants[2]+computed_constants[3])*constants[7]) - algebraic[24] = constants[26]-(constants[26]-constants[27])/(1.0+pow(constants[28]/states[2], constants[29])) - algebraic[26] = constants[31]*algebraic[24] + algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]) + algebraic[7] = algebraic[52]+algebraic[53] + algebraic[4] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[0], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[1]+110.0)/20.0), -1.0) + algebraic[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic[8]/computed_constants[0])+algebraic[0]/constants[19])+algebraic[0]/constants[18]*(1.0+algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])) + algebraic[13] = states[0]/constants[15]*exp(-constants[14]*algebraic[8]/computed_constants[0])/algebraic[20] + algebraic[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraic[8]/computed_constants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])) + algebraic[14] = constants[5]/constants[22]*exp(constants[21]*algebraic[8]/computed_constants[0])/algebraic[21] + algebraic[17] = exp(constants[16]*algebraic[8]/(2.0*computed_constants[0])) + algebraic[19] = algebraic[0]/constants[18]*algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])*exp(constants[16]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[20] + algebraic[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[21] + algebraic[9] = algebraic[18]*computed_constants[5]*(algebraic[19]+algebraic[13])+algebraic[19]*algebraic[14]*(computed_constants[5]+algebraic[17]) + algebraic[16] = algebraic[0]/(constants[13]+algebraic[0]) + algebraic[15] = exp(-constants[16]*algebraic[8]/(2.0*computed_constants[0])) + algebraic[10] = algebraic[19]*algebraic[16]*(algebraic[18]+algebraic[14])+algebraic[13]*algebraic[18]*(algebraic[16]+algebraic[15]) + algebraic[11] = algebraic[17]*algebraic[16]*(algebraic[19]+algebraic[13])+algebraic[15]*algebraic[13]*(computed_constants[5]+algebraic[17]) + algebraic[12] = algebraic[15]*computed_constants[5]*(algebraic[18]+algebraic[14])+algebraic[14]*algebraic[17]*(algebraic[16]+algebraic[15]) + algebraic[3] = (1.0-constants[12])*constants[11]*(algebraic[11]*algebraic[14]-algebraic[12]*algebraic[13])/(algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]) + rates[1] = (1.0-constants[7])*-1.0*(algebraic[7]+algebraic[6]+algebraic[5]+3.0*algebraic[4]+3.0*algebraic[3])/(1.0*(computed_constants[3]+computed_constants[2])*constants[6]) + algebraic[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])) algebraic[25] = constants[30]/algebraic[24] - rates[4] = constants[32]*states[5]-algebraic[26]*states[0]*states[4]-(algebraic[25]*pow(states[0], 2.0)*states[4]-constants[33]*states[3]) - rates[3] = algebraic[25]*pow(states[0], 2.0)*states[4]-constants[33]*states[3]-(algebraic[26]*states[0]*states[3]-constants[32]*states[6]) - rates[6] = algebraic[26]*states[0]*states[3]-constants[32]*states[6]-(constants[33]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]) - rates[5] = constants[33]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]-(constants[32]*states[5]-algebraic[26]*states[0]*states[4]) - algebraic[31] = constants[39]*states[7]*(1.0-states[9])-constants[40]*states[9] + algebraic[26] = constants[31]*algebraic[24] + rates[4] = constants[33]*states[5]-algebraic[26]*states[0]*states[4]-(algebraic[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]) + rates[3] = algebraic[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]-(algebraic[26]*states[0]*states[3]-constants[33]*states[6]) + rates[6] = algebraic[26]*states[0]*states[3]-constants[33]*states[6]-(constants[32]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]) + rates[5] = constants[32]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]-(constants[33]*states[5]-algebraic[26]*states[0]*states[4]) + algebraic[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9] rates[9] = algebraic[31] - algebraic[32] = constants[41]*states[7]*(1.0-(states[10]+states[11]))-constants[42]*states[10] + algebraic[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10] rates[10] = algebraic[32] - algebraic[33] = constants[43]*constants[44]*(1.0-(states[10]+states[11]))-constants[45]*states[11] + algebraic[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11] rates[11] = algebraic[33] - algebraic[34] = constants[46]*states[7]*(1.0-states[12])-constants[47]*states[12] + algebraic[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12] rates[12] = algebraic[34] - algebraic[35] = constants[46]*states[0]*(1.0-states[13])-constants[47]*states[13] + algebraic[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13] rates[13] = algebraic[35] - algebraic[36] = constants[48]*states[2]*(1.0-states[14])-constants[49]*states[14] + algebraic[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14] rates[14] = algebraic[36] + algebraic[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])) algebraic[28] = (states[0]-states[7])/constants[35] - algebraic[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[36])/constants[37])) - rates[7] = 1.0*(algebraic[28]*computed_constants[3]-algebraic[29]*computed_constants[8])/computed_constants[2]-(constants[52]*algebraic[34]+constants[50]*algebraic[31]+constants[51]*algebraic[32]) + rates[7] = 1.0*(algebraic[28]*computed_constants[2]-algebraic[29]*computed_constants[8])/computed_constants[3]-(constants[52]*algebraic[34]+constants[50]*algebraic[31]+constants[51]*algebraic[32]) algebraic[22] = constants[25]*states[3]*(states[2]-states[0]) - algebraic[37] = 2.0*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic[38] = 2.0*constants[84]*algebraic[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computed_constants[0]))*states[25]*states[24] - rates[0] = algebraic[22]*computed_constants[9]/computed_constants[3]-((algebraic[37]+algebraic[38]-2.0*algebraic[4])/(2.0*constants[7]*computed_constants[3])+algebraic[28]+constants[52]*algebraic[35]) + algebraic[37] = 2.0*constants[84]*algebraic[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computed_constants[0]))*states[25]*states[24] + algebraic[38] = 2.0*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + rates[0] = algebraic[22]*computed_constants[9]/computed_constants[2]-((algebraic[38]+algebraic[37]-2.0*algebraic[3])/(2.0*constants[6]*computed_constants[2])+algebraic[28]+constants[52]*algebraic[35]) algebraic[30] = (states[8]-states[2])/constants[38] rates[8] = algebraic[29]-algebraic[30]*computed_constants[9]/computed_constants[8] rates[2] = algebraic[30]-(algebraic[22]+constants[53]*algebraic[36]) + algebraic[39] = constants[76]*states[20]*states[19]*(algebraic[8]-computed_constants[1]) + algebraic[40] = constants[90]*constants[89]*(algebraic[8]-computed_constants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 + algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic[41] = (algebraic[38]+algebraic[67]+algebraic[5])*(1.0-computed_constants[19])*1.0*computed_constants[18] + algebraic[42] = constants[86]*(algebraic[8]-computed_constants[1])*states[27]*states[26] + algebraic[93] = computed_constants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraic[0])) + algebraic[43] = computed_constants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0) + algebraic[44] = constants[87]*(algebraic[8]-computed_constants[1])*(0.9*states[30]+0.1*states[29])*states[28] algebraic[48] = states[16]*computed_constants[15]*(algebraic[8]-computed_constants[1])*(1.0-constants[71]) - algebraic[40] = algebraic[7]+algebraic[48] - algebraic[41] = constants[76]*states[20]*states[19]*(algebraic[8]-computed_constants[1]) - algebraic[42] = constants[89]*constants[90]*(algebraic[8]-computed_constants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 - algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(constants[4]-constants[3]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic[43] = (algebraic[37]+algebraic[67]+algebraic[6])*(1.0-computed_constants[19])*1.0*computed_constants[18] - algebraic[44] = constants[86]*(algebraic[8]-computed_constants[1])*states[27]*states[26] - algebraic[93] = computed_constants[0]*log((constants[3]+0.12*constants[2])/(constants[4]+0.12*algebraic[1])) - algebraic[45] = computed_constants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0) - algebraic[46] = constants[87]*(algebraic[8]-computed_constants[1])*(0.9*states[29]+0.1*states[30])*states[28] - algebraic[39] = algebraic[40]+algebraic[46]+algebraic[45]+algebraic[44]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[43]+algebraic[38]+algebraic[42]+algebraic[41] - rates[15] = -algebraic[39]/constants[60] - algebraic[50] = 0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraic[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) + algebraic[45] = algebraic[6]+algebraic[48] + algebraic[46] = algebraic[45]+algebraic[44]+algebraic[43]+algebraic[42]+algebraic[4]+algebraic[3]+algebraic[7]+algebraic[41]+algebraic[37]+algebraic[40]+algebraic[39] + rates[15] = -algebraic[46]/constants[60] algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17])/(exp(0.066*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17]))-1.0)+0.1*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17]))))-0.054 + algebraic[50] = 0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraic[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) rates[16] = (algebraic[50]-states[16])/algebraic[49] - algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)) + algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)) algebraic[55] = algebraic[8]+41.0 algebraic[56] = 2000.0 if lt_func(fabs(algebraic[55]), constants[75]) else 200.0*algebraic[55]/(1.0-exp(-0.1*algebraic[55])) - algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)) algebraic[58] = 1.0/(algebraic[56]+algebraic[57]) + algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)) rates[18] = (algebraic[54]-states[18])/algebraic[58] - algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)) - algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)) algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0) + algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)) algebraic[62] = 1.0/(algebraic[60]+algebraic[61]) + algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)) rates[17] = (algebraic[59]-states[17])/algebraic[62] - algebraic[63] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)) - algebraic[64] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005 - rates[20] = (algebraic[63]-states[20])/algebraic[64] - algebraic[65] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)) - algebraic[66] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05 - rates[19] = (algebraic[65]-states[19])/algebraic[66] - algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[78]-computed_constants[20])/(constants[79]*(1.0+computed_constants[21]/100.0)))) + algebraic[63] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005 + algebraic[64] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)) + rates[20] = (algebraic[64]-states[20])/algebraic[63] + algebraic[65] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05 + algebraic[66] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)) + rates[19] = (algebraic[66]-states[19])/algebraic[65] + algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[79]-computed_constants[20])/(constants[78]*(1.0+computed_constants[21]/100.0)))) + algebraic[73] = -1.80001 if eq_func(algebraic[8], -1.8) else algebraic[8] + algebraic[69] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0) algebraic[72] = -41.80001 if eq_func(algebraic[8], -41.8) else 0.0 if eq_func(algebraic[8], 0.0) else -6.80001 if eq_func(algebraic[8], -6.8) else algebraic[8] algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0) - algebraic[73] = -1.80001 if eq_func(algebraic[8], -1.8) else algebraic[8] - algebraic[71] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0) - algebraic[69] = 0.001/(algebraic[70]+algebraic[71]) - rates[23] = (algebraic[68]-states[23])/algebraic[69] - algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[80])/(5.3+constants[81]))) + algebraic[71] = 0.001/(algebraic[70]+algebraic[69]) + rates[23] = (algebraic[68]-states[23])/algebraic[71] algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))) + algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[81])/(5.3+constants[80]))) rates[22] = (algebraic[74]-states[22])/algebraic[75] algebraic[76] = constants[82]/(constants[82]+states[0]) algebraic[77] = 0.001*algebraic[76]/constants[83] rates[21] = (algebraic[76]-states[21])/algebraic[77] - algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)) algebraic[79] = 0.001/(1.068*exp((algebraic[8]+38.3)/30.0)+1.068*exp(-(algebraic[8]+38.3)/30.0)) + algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)) rates[25] = (algebraic[78]-states[25])/algebraic[79] - algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)) algebraic[81] = 1.0/(16.67*exp(-(algebraic[8]+75.0)/83.3)+16.67*exp((algebraic[8]+75.0)/15.38))+constants[85] + algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)) rates[24] = (algebraic[80]-states[24])/algebraic[81] - algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)) algebraic[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[8]+44.0))+0.065*exp(0.1*(algebraic[8]+45.93)))+10.1) + algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)) rates[27] = (algebraic[82]-states[27])/algebraic[83] - algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)) algebraic[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[8]+30.61))+0.369*exp(-0.12*(algebraic[8]+23.84)))+2.98) + algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)) rates[26] = (algebraic[84]-states[26])/algebraic[85] - algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)) algebraic[89] = 0.84655354/(4.2*exp(algebraic[8]/17.0)+0.15*exp(-algebraic[8]/21.6)) - rates[30] = (algebraic[88]-states[30])/algebraic[89] + algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)) + rates[29] = (algebraic[88]-states[29])/algebraic[89] algebraic[90] = 1.0/(30.0*exp(algebraic[8]/10.0)+exp(-algebraic[8]/12.0)) - rates[29] = (algebraic[88]-states[29])/algebraic[90] - algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)) + rates[30] = (algebraic[88]-states[30])/algebraic[90] algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)) + algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)) rates[28] = (algebraic[92]-states[28])/algebraic[91] algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computed_constants[23])/10.7071))) + algebraic[95] = 1.0*exp(-(algebraic[8]-computed_constants[23]-5.0)/25.0) algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computed_constants[23])/3.0)) - algebraic[97] = 1.0*exp(-(algebraic[8]-computed_constants[23]-5.0)/25.0) - algebraic[95] = 1.0/(algebraic[96]+algebraic[97]) - rates[31] = (algebraic[94]-states[31])/algebraic[95] + algebraic[97] = 1.0/(algebraic[96]+algebraic[95]) + rates[31] = (algebraic[94]-states[31])/algebraic[97] algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)) - algebraic[99] = computed_constants[24]/(computed_constants[24]+algebraic[98]) algebraic[100] = 1.0/(computed_constants[24]+algebraic[98]) + algebraic[99] = computed_constants[24]/(computed_constants[24]+algebraic[98]) rates[32] = (algebraic[99]-states[32])/algebraic[100] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = states[1] - algebraic[0] = computed_constants[0]*log(constants[2]/algebraic[1]) + algebraic[0] = states[1] + algebraic[1] = computed_constants[0]*log(constants[2]/algebraic[0]) algebraic[2] = 0.5*computed_constants[0]*log(constants[5]/states[0]) algebraic[8] = algebraic[47] if geq_func(constants[63], 1.0) else states[15] - algebraic[5] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[3], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[1], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[0]+110.0)/20.0), -1.0) - algebraic[21] = 1.0+constants[5]/constants[21]*(1.0+exp(constants[22]*algebraic[8]/computed_constants[0]))+constants[2]/constants[23]*(1.0+constants[2]/constants[24]*(1.0+constants[2]/constants[20])) - algebraic[10] = constants[5]/constants[21]*exp(constants[22]*algebraic[8]/computed_constants[0])/algebraic[21] - algebraic[20] = 1.0+states[0]/constants[14]*(1.0+exp(-constants[15]*algebraic[8]/computed_constants[0])+algebraic[1]/constants[19])+algebraic[1]/constants[16]*(1.0+algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])) - algebraic[12] = states[0]/constants[14]*exp(-constants[15]*algebraic[8]/computed_constants[0])/algebraic[20] - algebraic[17] = algebraic[1]/(constants[13]+algebraic[1]) - algebraic[18] = exp(constants[18]*algebraic[8]/(2.0*computed_constants[0])) - algebraic[15] = exp(-constants[18]*algebraic[8]/(2.0*computed_constants[0])) - algebraic[19] = algebraic[1]/constants[16]*algebraic[1]/constants[17]*(1.0+algebraic[1]/constants[13])*exp(constants[18]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[20] - algebraic[9] = algebraic[18]*algebraic[17]*(algebraic[19]+algebraic[12])+algebraic[15]*algebraic[12]*(computed_constants[5]+algebraic[18]) - algebraic[16] = constants[2]/constants[23]*constants[2]/constants[24]*(1.0+constants[2]/constants[20])*exp(-constants[18]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[21] - algebraic[11] = algebraic[15]*computed_constants[5]*(algebraic[16]+algebraic[10])+algebraic[10]*algebraic[18]*(algebraic[17]+algebraic[15]) - algebraic[13] = algebraic[16]*computed_constants[5]*(algebraic[19]+algebraic[12])+algebraic[19]*algebraic[10]*(computed_constants[5]+algebraic[18]) - algebraic[14] = algebraic[19]*algebraic[17]*(algebraic[16]+algebraic[10])+algebraic[12]*algebraic[16]*(algebraic[17]+algebraic[15]) - algebraic[4] = (1.0-constants[11])*constants[12]*(algebraic[9]*algebraic[10]-algebraic[11]*algebraic[12])/(algebraic[11]+algebraic[9]+algebraic[14]+algebraic[13]) + algebraic[4] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[0], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[1]+110.0)/20.0), -1.0) + algebraic[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic[8]/computed_constants[0])+algebraic[0]/constants[19])+algebraic[0]/constants[18]*(1.0+algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])) + algebraic[13] = states[0]/constants[15]*exp(-constants[14]*algebraic[8]/computed_constants[0])/algebraic[20] + algebraic[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraic[8]/computed_constants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])) + algebraic[14] = constants[5]/constants[22]*exp(constants[21]*algebraic[8]/computed_constants[0])/algebraic[21] + algebraic[17] = exp(constants[16]*algebraic[8]/(2.0*computed_constants[0])) + algebraic[19] = algebraic[0]/constants[18]*algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])*exp(constants[16]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[20] + algebraic[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[21] + algebraic[9] = algebraic[18]*computed_constants[5]*(algebraic[19]+algebraic[13])+algebraic[19]*algebraic[14]*(computed_constants[5]+algebraic[17]) + algebraic[16] = algebraic[0]/(constants[13]+algebraic[0]) + algebraic[15] = exp(-constants[16]*algebraic[8]/(2.0*computed_constants[0])) + algebraic[10] = algebraic[19]*algebraic[16]*(algebraic[18]+algebraic[14])+algebraic[13]*algebraic[18]*(algebraic[16]+algebraic[15]) + algebraic[11] = algebraic[17]*algebraic[16]*(algebraic[19]+algebraic[13])+algebraic[15]*algebraic[13]*(computed_constants[5]+algebraic[17]) + algebraic[12] = algebraic[15]*computed_constants[5]*(algebraic[18]+algebraic[14])+algebraic[14]*algebraic[17]*(algebraic[16]+algebraic[15]) + algebraic[3] = (1.0-constants[12])*constants[11]*(algebraic[11]*algebraic[14]-algebraic[12]*algebraic[13])/(algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]) algebraic[22] = constants[25]*states[3]*(states[2]-states[0]) algebraic[23] = states[2]-states[0] - algebraic[24] = constants[26]-(constants[26]-constants[27])/(1.0+pow(constants[28]/states[2], constants[29])) + algebraic[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])) algebraic[25] = constants[30]/algebraic[24] algebraic[26] = constants[31]*algebraic[24] algebraic[27] = states[4]+states[3]+states[6]+states[5] algebraic[28] = (states[0]-states[7])/constants[35] - algebraic[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[36])/constants[37])) + algebraic[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])) algebraic[30] = (states[8]-states[2])/constants[38] - algebraic[31] = constants[39]*states[7]*(1.0-states[9])-constants[40]*states[9] - algebraic[32] = constants[41]*states[7]*(1.0-(states[10]+states[11]))-constants[42]*states[10] - algebraic[33] = constants[43]*constants[44]*(1.0-(states[10]+states[11]))-constants[45]*states[11] - algebraic[34] = constants[46]*states[7]*(1.0-states[12])-constants[47]*states[12] - algebraic[35] = constants[46]*states[0]*(1.0-states[13])-constants[47]*states[13] - algebraic[36] = constants[48]*states[2]*(1.0-states[14])-constants[49]*states[14] - algebraic[7] = states[16]*computed_constants[14]*(algebraic[8]-algebraic[0])*(1.0-constants[71]) - algebraic[48] = states[16]*computed_constants[15]*(algebraic[8]-computed_constants[1])*(1.0-constants[71]) - algebraic[40] = algebraic[7]+algebraic[48] - algebraic[41] = constants[76]*states[20]*states[19]*(algebraic[8]-computed_constants[1]) - algebraic[42] = constants[89]*constants[90]*(algebraic[8]-computed_constants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 - algebraic[38] = 2.0*constants[84]*algebraic[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computed_constants[0]))*states[25]*states[24] - algebraic[37] = 2.0*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic[6] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(algebraic[1]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(constants[4]-constants[3]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic[43] = (algebraic[37]+algebraic[67]+algebraic[6])*(1.0-computed_constants[19])*1.0*computed_constants[18] - algebraic[51] = computed_constants[0]*log((constants[2]+0.12*constants[3])/(algebraic[1]+0.12*constants[4])) - algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]) + algebraic[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9] + algebraic[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10] + algebraic[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11] + algebraic[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12] + algebraic[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13] + algebraic[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14] + algebraic[39] = constants[76]*states[20]*states[19]*(algebraic[8]-computed_constants[1]) + algebraic[40] = constants[90]*constants[89]*(algebraic[8]-computed_constants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 + algebraic[37] = 2.0*constants[84]*algebraic[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computed_constants[0]))*states[25]*states[24] + algebraic[5] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(algebraic[0]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic[38] = 2.0*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraic[41] = (algebraic[38]+algebraic[67]+algebraic[5])*(1.0-computed_constants[19])*1.0*computed_constants[18] + algebraic[51] = computed_constants[0]*log((constants[2]+0.12*constants[4])/(algebraic[0]+0.12*constants[3])) algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]) - algebraic[3] = algebraic[52]+algebraic[53] - algebraic[44] = constants[86]*(algebraic[8]-computed_constants[1])*states[27]*states[26] - algebraic[93] = computed_constants[0]*log((constants[3]+0.12*constants[2])/(constants[4]+0.12*algebraic[1])) - algebraic[45] = computed_constants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0) - algebraic[46] = constants[87]*(algebraic[8]-computed_constants[1])*(0.9*states[29]+0.1*states[30])*states[28] - algebraic[39] = algebraic[40]+algebraic[46]+algebraic[45]+algebraic[44]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[43]+algebraic[38]+algebraic[42]+algebraic[41] + algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]) + algebraic[7] = algebraic[52]+algebraic[53] + algebraic[42] = constants[86]*(algebraic[8]-computed_constants[1])*states[27]*states[26] + algebraic[93] = computed_constants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraic[0])) + algebraic[43] = computed_constants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0) + algebraic[44] = constants[87]*(algebraic[8]-computed_constants[1])*(0.9*states[30]+0.1*states[29])*states[28] + algebraic[48] = states[16]*computed_constants[15]*(algebraic[8]-computed_constants[1])*(1.0-constants[71]) + algebraic[6] = states[16]*computed_constants[14]*(algebraic[8]-algebraic[1])*(1.0-constants[71]) + algebraic[45] = algebraic[6]+algebraic[48] + algebraic[46] = algebraic[45]+algebraic[44]+algebraic[43]+algebraic[42]+algebraic[4]+algebraic[3]+algebraic[7]+algebraic[41]+algebraic[37]+algebraic[40]+algebraic[39] algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17])/(exp(0.066*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17]))-1.0)+0.1*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17]))))-0.054 algebraic[50] = 0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraic[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)) @@ -665,17 +665,17 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)) algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0) algebraic[62] = 1.0/(algebraic[60]+algebraic[61]) - algebraic[63] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)) - algebraic[64] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005 - algebraic[65] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)) - algebraic[66] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05 - algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[78]-computed_constants[20])/(constants[79]*(1.0+computed_constants[21]/100.0)))) + algebraic[64] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)) + algebraic[63] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005 + algebraic[66] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)) + algebraic[65] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05 + algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[79]-computed_constants[20])/(constants[78]*(1.0+computed_constants[21]/100.0)))) + algebraic[73] = -1.80001 if eq_func(algebraic[8], -1.8) else algebraic[8] + algebraic[69] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0) algebraic[72] = -41.80001 if eq_func(algebraic[8], -41.8) else 0.0 if eq_func(algebraic[8], 0.0) else -6.80001 if eq_func(algebraic[8], -6.8) else algebraic[8] algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0) - algebraic[73] = -1.80001 if eq_func(algebraic[8], -1.8) else algebraic[8] - algebraic[71] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0) - algebraic[69] = 0.001/(algebraic[70]+algebraic[71]) - algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[80])/(5.3+constants[81]))) + algebraic[71] = 0.001/(algebraic[70]+algebraic[69]) + algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[81])/(5.3+constants[80]))) algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))) algebraic[76] = constants[82]/(constants[82]+states[0]) algebraic[77] = 0.001*algebraic[76]/constants[83] @@ -695,9 +695,9 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)) algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)) algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computed_constants[23])/10.7071))) + algebraic[95] = 1.0*exp(-(algebraic[8]-computed_constants[23]-5.0)/25.0) algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computed_constants[23])/3.0)) - algebraic[97] = 1.0*exp(-(algebraic[8]-computed_constants[23]-5.0)/25.0) - algebraic[95] = 1.0/(algebraic[96]+algebraic[97]) + algebraic[97] = 1.0/(algebraic[96]+algebraic[95]) algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)) algebraic[99] = computed_constants[24]/(computed_constants[24]+algebraic[98]) algebraic[100] = 1.0/(computed_constants[24]+algebraic[98]) diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 48a1746f9..38344edb9 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -18,17 +18,17 @@ const VariableInfo VOI_INFO = {"time", "second", "environment"}; const VariableInfo STATE_INFO[] = { {"V", "millivolt", "membrane"}, {"m", "dimensionless", "sodium_current_m_gate"}, - {"h1", "dimensionless", "sodium_current_h_gate"}, {"h2", "dimensionless", "sodium_current_h_gate"}, - {"f_L", "dimensionless", "L_type_Ca_channel_f_gate"}, + {"h1", "dimensionless", "sodium_current_h_gate"}, {"d_L", "dimensionless", "L_type_Ca_channel_d_gate"}, + {"f_L", "dimensionless", "L_type_Ca_channel_f_gate"}, {"f_T", "dimensionless", "T_type_Ca_channel_f_gate"}, {"d_T", "dimensionless", "T_type_Ca_channel_d_gate"}, {"r", "dimensionless", "four_AP_sensitive_currents_r_gate"}, {"q", "dimensionless", "four_AP_sensitive_currents_q_gate"}, {"P_i", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_i_gate"}, - {"P_af", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_af_gate"}, {"P_as", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"P_af", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_af_gate"}, {"xs", "dimensionless", "slow_delayed_rectifying_potassium_current_xs_gate"}, {"y", "dimensionless", "hyperpolarisation_activated_current_y_gate"} }; @@ -67,11 +67,11 @@ const VariableInfo CONSTANT_INFO[] = { {"k_NaCa_Centre_0DCapable", "nanoA", "sodium_calcium_exchanger"}, {"k_NaCa_Periphery_0DCapable", "nanoA", "sodium_calcium_exchanger"}, {"Na_i", "millimolar", "ionic_concentrations"}, - {"gamma_NaCa", "dimensionless", "sodium_calcium_exchanger"}, {"Ca_o", "millimolar", "ionic_concentrations"}, {"Na_o", "millimolar", "ionic_concentrations"}, {"Ca_i", "millimolar", "ionic_concentrations"}, {"d_NaCa", "dimensionless", "sodium_calcium_exchanger"}, + {"gamma_NaCa", "dimensionless", "sodium_calcium_exchanger"}, {"i_p_max_Centre_Published", "nanoA", "sodium_potassium_pump"}, {"i_p_max_Periphery_Published", "nanoA", "sodium_potassium_pump"}, {"i_p_max_Centre_1DCapable", "nanoA", "sodium_potassium_pump"}, @@ -173,7 +173,6 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Na", "nanoA", "sodium_current"}, {"i_p", "nanoA", "sodium_potassium_pump"}, {"i_NaCa", "nanoA", "sodium_calcium_exchanger"}, {"i_b_K", "nanoA", "potassium_background_current"}, @@ -187,44 +186,45 @@ const VariableInfo ALGEBRAIC_INFO[] = { {"i_to", "nanoA", "four_AP_sensitive_currents"}, {"i_Ca_T", "nanoA", "T_type_Ca_channel"}, {"i_Ca_L", "nanoA", "L_type_Ca_channel"}, + {"i_Na", "nanoA", "sodium_current"}, {"h", "dimensionless", "sodium_current_h_gate"}, - {"m_infinity", "dimensionless", "sodium_current_m_gate"}, {"tau_m", "second", "sodium_current_m_gate"}, + {"m_infinity", "dimensionless", "sodium_current_m_gate"}, {"F_Na", "dimensionless", "sodium_current_h_gate"}, - {"h1_infinity", "dimensionless", "sodium_current_h_gate"}, {"tau_h1", "second", "sodium_current_h_gate"}, - {"h2_infinity", "dimensionless", "sodium_current_h_gate"}, + {"h1_infinity", "dimensionless", "sodium_current_h_gate"}, {"tau_h2", "second", "sodium_current_h_gate"}, - {"d_L_infinity", "dimensionless", "L_type_Ca_channel_d_gate"}, + {"h2_infinity", "dimensionless", "sodium_current_h_gate"}, {"tau_d_L", "second", "L_type_Ca_channel_d_gate"}, + {"d_L_infinity", "dimensionless", "L_type_Ca_channel_d_gate"}, {"alpha_d_L", "per_second", "L_type_Ca_channel_d_gate"}, {"beta_d_L", "per_second", "L_type_Ca_channel_d_gate"}, - {"f_L_infinity", "dimensionless", "L_type_Ca_channel_f_gate"}, {"tau_f_L", "second", "L_type_Ca_channel_f_gate"}, + {"f_L_infinity", "dimensionless", "L_type_Ca_channel_f_gate"}, {"alpha_f_L", "per_second", "L_type_Ca_channel_f_gate"}, {"beta_f_L", "per_second", "L_type_Ca_channel_f_gate"}, - {"d_T_infinity", "dimensionless", "T_type_Ca_channel_d_gate"}, {"tau_d_T", "second", "T_type_Ca_channel_d_gate"}, + {"d_T_infinity", "dimensionless", "T_type_Ca_channel_d_gate"}, {"alpha_d_T", "per_second", "T_type_Ca_channel_d_gate"}, {"beta_d_T", "per_second", "T_type_Ca_channel_d_gate"}, - {"f_T_infinity", "dimensionless", "T_type_Ca_channel_f_gate"}, {"tau_f_T", "second", "T_type_Ca_channel_f_gate"}, + {"f_T_infinity", "dimensionless", "T_type_Ca_channel_f_gate"}, {"alpha_f_T", "per_second", "T_type_Ca_channel_f_gate"}, {"beta_f_T", "per_second", "T_type_Ca_channel_f_gate"}, - {"q_infinity", "dimensionless", "four_AP_sensitive_currents_q_gate"}, {"tau_q", "second", "four_AP_sensitive_currents_q_gate"}, - {"r_infinity", "dimensionless", "four_AP_sensitive_currents_r_gate"}, + {"q_infinity", "dimensionless", "four_AP_sensitive_currents_q_gate"}, {"tau_r", "second", "four_AP_sensitive_currents_r_gate"}, + {"r_infinity", "dimensionless", "four_AP_sensitive_currents_r_gate"}, {"P_a", "dimensionless", "rapid_delayed_rectifying_potassium_current"}, - {"P_af_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_af_gate"}, {"tau_P_af", "second", "rapid_delayed_rectifying_potassium_current_P_af_gate"}, - {"P_as_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"P_af_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_af_gate"}, {"tau_P_as", "second", "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"P_as_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_as_gate"}, {"P_i_infinity", "dimensionless", "rapid_delayed_rectifying_potassium_current_P_i_gate"}, - {"alpha_xs", "per_second", "slow_delayed_rectifying_potassium_current_xs_gate"}, {"beta_xs", "per_second", "slow_delayed_rectifying_potassium_current_xs_gate"}, - {"alpha_y", "per_second", "hyperpolarisation_activated_current_y_gate"}, - {"beta_y", "per_second", "hyperpolarisation_activated_current_y_gate"} + {"alpha_xs", "per_second", "slow_delayed_rectifying_potassium_current_xs_gate"}, + {"beta_y", "per_second", "hyperpolarisation_activated_current_y_gate"}, + {"alpha_y", "per_second", "hyperpolarisation_activated_current_y_gate"} }; double * createStatesArray() @@ -280,17 +280,17 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl { states[0] = -39.013558536; states[1] = 0.092361701692; - states[2] = 0.015905380261; - states[3] = 0.01445216109; - states[4] = 0.48779845203; - states[5] = 0.04804900895; + states[2] = 0.01445216109; + states[3] = 0.015905380261; + states[4] = 0.04804900895; + states[5] = 0.48779845203; states[6] = 0.038968420558; states[7] = 0.42074047435; states[8] = 0.064402950262; states[9] = 0.29760539675; states[10] = 0.87993375273; - states[11] = 0.13034201158; - states[12] = 0.46960956028; + states[11] = 0.46960956028; + states[12] = 0.13034201158; states[13] = 0.082293827208; states[14] = 0.03889291759; constants[0] = 0.0; @@ -326,11 +326,11 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[30] = 2.7229e-6; constants[31] = 8.83584e-6; constants[32] = 8.0; - constants[33] = 0.5; - constants[34] = 2.0; - constants[35] = 140.0; + constants[33] = 2.0; + constants[34] = 140.0; + constants[35] = 0.0001; constants[36] = 0.0001; - constants[37] = 0.0001; + constants[37] = 0.5; constants[38] = 0.0478; constants[39] = 0.16; constants[40] = 0.0478; @@ -415,11 +415,11 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[9] = (constants[1] == 0.0)?constants[26]+computedConstants[0]*(constants[27]-constants[26]):(constants[1] == 1.0)?constants[30]+computedConstants[0]*(constants[31]-constants[30]):constants[28]+computedConstants[0]*(constants[29]-constants[28]); computedConstants[10] = (constants[1] == 0.0)?constants[38]+computedConstants[0]*(constants[39]-constants[38]):(constants[1] == 1.0)?constants[42]+computedConstants[0]*(constants[43]-constants[42]):constants[40]+computedConstants[0]*(constants[41]-constants[40]); computedConstants[11] = (constants[1] == 0.0)?constants[47]+computedConstants[0]*(constants[48]-constants[47]):(constants[1] == 1.0)?constants[51]+computedConstants[0]*(constants[52]-constants[51]):constants[49]+computedConstants[0]*(constants[50]-constants[49]); - computedConstants[2] = computedConstants[11]*constants[36]/(constants[36]+0.0004); - computedConstants[4] = constants[5]*constants[6]/constants[7]*log(constants[35]/constants[32]); + computedConstants[2] = computedConstants[11]*constants[35]/(constants[35]+0.0004); + computedConstants[4] = constants[5]*constants[6]/constants[7]*log(constants[34]/constants[32]); computedConstants[6] = constants[5]*constants[6]/constants[7]*log(constants[44]/constants[53]); - computedConstants[8] = constants[5]*constants[6]/(2.0*constants[7])*log(constants[34]/constants[36]); - computedConstants[12] = (constants[1] == 0.0)?constants[5]*constants[6]/constants[7]*log((constants[44]+0.12*constants[35])/(constants[53]+0.12*constants[32])):constants[5]*constants[6]/constants[7]*log((constants[44]+0.03*constants[35])/(constants[53]+0.03*constants[32])); + computedConstants[8] = constants[5]*constants[6]/(2.0*constants[7])*log(constants[33]/constants[35]); + computedConstants[12] = (constants[1] == 0.0)?constants[5]*constants[6]/constants[7]*log((constants[44]+0.12*constants[34])/(constants[53]+0.12*constants[32])):constants[5]*constants[6]/constants[7]*log((constants[44]+0.03*constants[34])/(constants[53]+0.03*constants[32])); computedConstants[13] = (constants[1] == 0.0)?constants[54]+computedConstants[0]*(constants[55]-constants[54]):(constants[1] == 1.0)?constants[58]+computedConstants[0]*(constants[59]-constants[58]):constants[56]+computedConstants[0]*(constants[57]-constants[56]); computedConstants[14] = (constants[1] == 0.0)?constants[60]+computedConstants[0]*(constants[61]-constants[60]):(constants[1] == 1.0)?constants[64]+computedConstants[0]*(constants[65]-constants[64]):constants[62]+computedConstants[0]*(constants[63]-constants[62]); computedConstants[15] = (constants[1] == 0.0)?constants[67]+computedConstants[0]*(constants[68]-constants[67]):(constants[1] == 1.0)?constants[71]+computedConstants[0]*(constants[72]-constants[71]):constants[69]+computedConstants[0]*(constants[70]-constants[69]); @@ -434,127 +434,127 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[1] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); - algebraic[2] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.0374*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.03743*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))); - algebraic[6] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); - algebraic[7] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); - algebraic[8] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); - algebraic[10] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); - algebraic[11] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); - algebraic[12] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); - algebraic[13] = computedConstants[14]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); + algebraic[0] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); + algebraic[1] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))); + algebraic[5] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); + algebraic[6] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); + algebraic[7] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); + algebraic[9] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); + algebraic[10] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); + algebraic[11] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); + algebraic[12] = computedConstants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); + algebraic[2] = computedConstants[5]*(states[0]-computedConstants[6]); + algebraic[3] = computedConstants[7]*(states[0]-computedConstants[8]); + algebraic[4] = computedConstants[3]*(states[0]-computedConstants[4]); + algebraic[42] = 0.6*states[12]+0.4*states[11]; + algebraic[8] = computedConstants[18]*algebraic[42]*states[10]*(states[0]-computedConstants[6]); algebraic[17] = (constants[1] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; - algebraic[14] = (1.0-algebraic[17])*states[2]+algebraic[17]*states[3]; - algebraic[0] = computedConstants[13]*pow(states[1], 3.0)*algebraic[14]*constants[35]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; - algebraic[3] = computedConstants[5]*(states[0]-computedConstants[6]); - algebraic[4] = computedConstants[7]*(states[0]-computedConstants[8]); - algebraic[5] = computedConstants[3]*(states[0]-computedConstants[4]); - algebraic[42] = 0.6*states[11]+0.4*states[12]; - algebraic[9] = computedConstants[18]*algebraic[42]*states[10]*(states[0]-computedConstants[6]); - rates[0] = -1.0/computedConstants[1]*(algebraic[0]+algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+algebraic[8]+algebraic[7]+algebraic[6]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[2]+algebraic[1]+computedConstants[2]); - algebraic[15] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); - algebraic[16] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; - rates[1] = (algebraic[15]-states[1])/algebraic[16]; - algebraic[18] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); - algebraic[19] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; - rates[2] = (algebraic[18]-states[2])/algebraic[19]; - algebraic[20] = algebraic[18]; - algebraic[21] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; - rates[3] = (algebraic[20]-states[3])/algebraic[21]; - algebraic[22] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); - algebraic[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); + algebraic[14] = (1.0-algebraic[17])*states[3]+algebraic[17]*states[2]; + algebraic[13] = computedConstants[13]*pow(states[1], 3.0)*algebraic[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; + rates[0] = -1.0/computedConstants[1]*(algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+algebraic[8]+algebraic[7]+algebraic[6]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[2]+algebraic[1]+algebraic[0]+computedConstants[2]); + algebraic[15] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; + algebraic[16] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); + rates[1] = (algebraic[16]-states[1])/algebraic[15]; + algebraic[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; + algebraic[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); + rates[3] = (algebraic[19]-states[3])/algebraic[18]; + algebraic[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; + algebraic[21] = algebraic[19]; + rates[2] = (algebraic[21]-states[2])/algebraic[20]; algebraic[25] = (constants[1] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); - algebraic[23] = 2.0/(algebraic[24]+algebraic[25]); - rates[5] = (algebraic[22]-states[5])/algebraic[23]; - algebraic[26] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); - algebraic[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); + algebraic[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); + algebraic[22] = 2.0/(algebraic[24]+algebraic[25]); + algebraic[23] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); + rates[4] = (algebraic[23]-states[4])/algebraic[22]; algebraic[29] = (constants[1] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); - algebraic[27] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[28]+algebraic[29]):1.0/(algebraic[28]+algebraic[29]); - rates[4] = (algebraic[26]-states[4])/algebraic[27]; - algebraic[30] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); - algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0); + algebraic[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); + algebraic[26] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[28]+algebraic[29]):1.0/(algebraic[28]+algebraic[29]); + algebraic[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); + rates[5] = (algebraic[27]-states[5])/algebraic[26]; algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0); - algebraic[31] = 1.0/(algebraic[32]+algebraic[33]); - rates[7] = (algebraic[30]-states[7])/algebraic[31]; - algebraic[34] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); - algebraic[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); + algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0); + algebraic[30] = 1.0/(algebraic[32]+algebraic[33]); + algebraic[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); + rates[7] = (algebraic[31]-states[7])/algebraic[30]; algebraic[37] = (constants[1] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); - algebraic[35] = 1.0/(algebraic[36]+algebraic[37]); - rates[6] = (algebraic[34]-states[6])/algebraic[35]; - algebraic[38] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); - algebraic[39] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); - rates[9] = (algebraic[38]-states[9])/algebraic[39]; - algebraic[40] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); - algebraic[41] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); - rates[8] = (algebraic[40]-states[8])/algebraic[41]; - algebraic[43] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); - algebraic[44] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); - rates[11] = (algebraic[43]-states[11])/algebraic[44]; - algebraic[45] = algebraic[43]; - algebraic[46] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); - rates[12] = (algebraic[45]-states[12])/algebraic[46]; + algebraic[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); + algebraic[34] = 1.0/(algebraic[36]+algebraic[37]); + algebraic[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); + rates[6] = (algebraic[35]-states[6])/algebraic[34]; + algebraic[38] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); + algebraic[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); + rates[9] = (algebraic[39]-states[9])/algebraic[38]; + algebraic[40] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); + algebraic[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); + rates[8] = (algebraic[41]-states[8])/algebraic[40]; + algebraic[43] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); + algebraic[44] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); + rates[12] = (algebraic[44]-states[12])/algebraic[43]; + algebraic[45] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); + algebraic[46] = algebraic[44]; + rates[11] = (algebraic[46]-states[11])/algebraic[45]; algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); rates[10] = (algebraic[47]-states[10])/computedConstants[19]; - algebraic[48] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); - algebraic[49] = 1.0*exp(-states[0]/45.0); - rates[13] = algebraic[48]*(1.0-states[13])-algebraic[49]*states[13]; - algebraic[50] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); - algebraic[51] = 1.0*exp((states[0]+75.13)/21.25); - rates[14] = algebraic[50]*(1.0-states[14])-algebraic[51]*states[14]; + algebraic[48] = 1.0*exp(-states[0]/45.0); + algebraic[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); + rates[13] = algebraic[49]*(1.0-states[13])-algebraic[48]*states[13]; + algebraic[50] = 1.0*exp((states[0]+75.13)/21.25); + algebraic[51] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); + rates[14] = algebraic[51]*(1.0-states[14])-algebraic[50]*states[14]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[5] = computedConstants[3]*(states[0]-computedConstants[4]); - algebraic[3] = computedConstants[5]*(states[0]-computedConstants[6]); - algebraic[4] = computedConstants[7]*(states[0]-computedConstants[8]); - algebraic[2] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.0374*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.03743*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))); - algebraic[1] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); + algebraic[4] = computedConstants[3]*(states[0]-computedConstants[4]); + algebraic[2] = computedConstants[5]*(states[0]-computedConstants[6]); + algebraic[3] = computedConstants[7]*(states[0]-computedConstants[8]); + algebraic[1] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))); + algebraic[0] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); algebraic[17] = (constants[1] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; - algebraic[14] = (1.0-algebraic[17])*states[2]+algebraic[17]*states[3]; - algebraic[0] = computedConstants[13]*pow(states[1], 3.0)*algebraic[14]*constants[35]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; - algebraic[15] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); - algebraic[16] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; - algebraic[18] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); - algebraic[20] = algebraic[18]; - algebraic[19] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; - algebraic[21] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; - algebraic[13] = computedConstants[14]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); + algebraic[14] = (1.0-algebraic[17])*states[3]+algebraic[17]*states[2]; + algebraic[13] = computedConstants[13]*pow(states[1], 3.0)*algebraic[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; + algebraic[16] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); + algebraic[15] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; + algebraic[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); + algebraic[21] = algebraic[19]; + algebraic[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; + algebraic[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; + algebraic[12] = computedConstants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); algebraic[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); algebraic[25] = (constants[1] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); - algebraic[23] = 2.0/(algebraic[24]+algebraic[25]); - algebraic[22] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); + algebraic[22] = 2.0/(algebraic[24]+algebraic[25]); + algebraic[23] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); algebraic[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); algebraic[29] = (constants[1] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); - algebraic[27] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[28]+algebraic[29]):1.0/(algebraic[28]+algebraic[29]); - algebraic[26] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); - algebraic[12] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); + algebraic[26] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[28]+algebraic[29]):1.0/(algebraic[28]+algebraic[29]); + algebraic[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); + algebraic[11] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0); algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0); - algebraic[31] = 1.0/(algebraic[32]+algebraic[33]); - algebraic[30] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); + algebraic[30] = 1.0/(algebraic[32]+algebraic[33]); + algebraic[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); algebraic[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); algebraic[37] = (constants[1] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); - algebraic[35] = 1.0/(algebraic[36]+algebraic[37]); - algebraic[34] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); - algebraic[11] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); - algebraic[10] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); - algebraic[38] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); - algebraic[39] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); - algebraic[40] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); - algebraic[41] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); - algebraic[42] = 0.6*states[11]+0.4*states[12]; - algebraic[9] = computedConstants[18]*algebraic[42]*states[10]*(states[0]-computedConstants[6]); - algebraic[43] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); - algebraic[44] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); - algebraic[45] = algebraic[43]; - algebraic[46] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); + algebraic[34] = 1.0/(algebraic[36]+algebraic[37]); + algebraic[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); + algebraic[10] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); + algebraic[9] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); + algebraic[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); + algebraic[38] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); + algebraic[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); + algebraic[40] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); + algebraic[42] = 0.6*states[12]+0.4*states[11]; + algebraic[8] = computedConstants[18]*algebraic[42]*states[10]*(states[0]-computedConstants[6]); + algebraic[44] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); + algebraic[43] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); + algebraic[46] = algebraic[44]; + algebraic[45] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); - algebraic[8] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); - algebraic[48] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); - algebraic[49] = 1.0*exp(-states[0]/45.0); - algebraic[7] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); - algebraic[6] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); - algebraic[50] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); - algebraic[51] = 1.0*exp((states[0]+75.13)/21.25); + algebraic[7] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); + algebraic[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); + algebraic[48] = 1.0*exp(-states[0]/45.0); + algebraic[6] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); + algebraic[5] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); + algebraic[51] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); + algebraic[50] = 1.0*exp((states[0]+75.13)/21.25); } diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 6ebe495f3..049b8e1fd 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -17,17 +17,17 @@ STATE_INFO = [ {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "m", "units": "dimensionless", "component": "sodium_current_m_gate"}, - {"name": "h1", "units": "dimensionless", "component": "sodium_current_h_gate"}, {"name": "h2", "units": "dimensionless", "component": "sodium_current_h_gate"}, - {"name": "f_L", "units": "dimensionless", "component": "L_type_Ca_channel_f_gate"}, + {"name": "h1", "units": "dimensionless", "component": "sodium_current_h_gate"}, {"name": "d_L", "units": "dimensionless", "component": "L_type_Ca_channel_d_gate"}, + {"name": "f_L", "units": "dimensionless", "component": "L_type_Ca_channel_f_gate"}, {"name": "f_T", "units": "dimensionless", "component": "T_type_Ca_channel_f_gate"}, {"name": "d_T", "units": "dimensionless", "component": "T_type_Ca_channel_d_gate"}, {"name": "r", "units": "dimensionless", "component": "four_AP_sensitive_currents_r_gate"}, {"name": "q", "units": "dimensionless", "component": "four_AP_sensitive_currents_q_gate"}, {"name": "P_i", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate"}, - {"name": "P_af", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate"}, {"name": "P_as", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"name": "P_af", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate"}, {"name": "xs", "units": "dimensionless", "component": "slow_delayed_rectifying_potassium_current_xs_gate"}, {"name": "y", "units": "dimensionless", "component": "hyperpolarisation_activated_current_y_gate"} ] @@ -66,11 +66,11 @@ {"name": "k_NaCa_Centre_0DCapable", "units": "nanoA", "component": "sodium_calcium_exchanger"}, {"name": "k_NaCa_Periphery_0DCapable", "units": "nanoA", "component": "sodium_calcium_exchanger"}, {"name": "Na_i", "units": "millimolar", "component": "ionic_concentrations"}, - {"name": "gamma_NaCa", "units": "dimensionless", "component": "sodium_calcium_exchanger"}, {"name": "Ca_o", "units": "millimolar", "component": "ionic_concentrations"}, {"name": "Na_o", "units": "millimolar", "component": "ionic_concentrations"}, {"name": "Ca_i", "units": "millimolar", "component": "ionic_concentrations"}, {"name": "d_NaCa", "units": "dimensionless", "component": "sodium_calcium_exchanger"}, + {"name": "gamma_NaCa", "units": "dimensionless", "component": "sodium_calcium_exchanger"}, {"name": "i_p_max_Centre_Published", "units": "nanoA", "component": "sodium_potassium_pump"}, {"name": "i_p_max_Periphery_Published", "units": "nanoA", "component": "sodium_potassium_pump"}, {"name": "i_p_max_Centre_1DCapable", "units": "nanoA", "component": "sodium_potassium_pump"}, @@ -172,7 +172,6 @@ ] ALGEBRAIC_INFO = [ - {"name": "i_Na", "units": "nanoA", "component": "sodium_current"}, {"name": "i_p", "units": "nanoA", "component": "sodium_potassium_pump"}, {"name": "i_NaCa", "units": "nanoA", "component": "sodium_calcium_exchanger"}, {"name": "i_b_K", "units": "nanoA", "component": "potassium_background_current"}, @@ -186,44 +185,45 @@ {"name": "i_to", "units": "nanoA", "component": "four_AP_sensitive_currents"}, {"name": "i_Ca_T", "units": "nanoA", "component": "T_type_Ca_channel"}, {"name": "i_Ca_L", "units": "nanoA", "component": "L_type_Ca_channel"}, + {"name": "i_Na", "units": "nanoA", "component": "sodium_current"}, {"name": "h", "units": "dimensionless", "component": "sodium_current_h_gate"}, - {"name": "m_infinity", "units": "dimensionless", "component": "sodium_current_m_gate"}, {"name": "tau_m", "units": "second", "component": "sodium_current_m_gate"}, + {"name": "m_infinity", "units": "dimensionless", "component": "sodium_current_m_gate"}, {"name": "F_Na", "units": "dimensionless", "component": "sodium_current_h_gate"}, - {"name": "h1_infinity", "units": "dimensionless", "component": "sodium_current_h_gate"}, {"name": "tau_h1", "units": "second", "component": "sodium_current_h_gate"}, - {"name": "h2_infinity", "units": "dimensionless", "component": "sodium_current_h_gate"}, + {"name": "h1_infinity", "units": "dimensionless", "component": "sodium_current_h_gate"}, {"name": "tau_h2", "units": "second", "component": "sodium_current_h_gate"}, - {"name": "d_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_d_gate"}, + {"name": "h2_infinity", "units": "dimensionless", "component": "sodium_current_h_gate"}, {"name": "tau_d_L", "units": "second", "component": "L_type_Ca_channel_d_gate"}, + {"name": "d_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_d_gate"}, {"name": "alpha_d_L", "units": "per_second", "component": "L_type_Ca_channel_d_gate"}, {"name": "beta_d_L", "units": "per_second", "component": "L_type_Ca_channel_d_gate"}, - {"name": "f_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_f_gate"}, {"name": "tau_f_L", "units": "second", "component": "L_type_Ca_channel_f_gate"}, + {"name": "f_L_infinity", "units": "dimensionless", "component": "L_type_Ca_channel_f_gate"}, {"name": "alpha_f_L", "units": "per_second", "component": "L_type_Ca_channel_f_gate"}, {"name": "beta_f_L", "units": "per_second", "component": "L_type_Ca_channel_f_gate"}, - {"name": "d_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_d_gate"}, {"name": "tau_d_T", "units": "second", "component": "T_type_Ca_channel_d_gate"}, + {"name": "d_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_d_gate"}, {"name": "alpha_d_T", "units": "per_second", "component": "T_type_Ca_channel_d_gate"}, {"name": "beta_d_T", "units": "per_second", "component": "T_type_Ca_channel_d_gate"}, - {"name": "f_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_f_gate"}, {"name": "tau_f_T", "units": "second", "component": "T_type_Ca_channel_f_gate"}, + {"name": "f_T_infinity", "units": "dimensionless", "component": "T_type_Ca_channel_f_gate"}, {"name": "alpha_f_T", "units": "per_second", "component": "T_type_Ca_channel_f_gate"}, {"name": "beta_f_T", "units": "per_second", "component": "T_type_Ca_channel_f_gate"}, - {"name": "q_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_q_gate"}, {"name": "tau_q", "units": "second", "component": "four_AP_sensitive_currents_q_gate"}, - {"name": "r_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_r_gate"}, + {"name": "q_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_q_gate"}, {"name": "tau_r", "units": "second", "component": "four_AP_sensitive_currents_r_gate"}, + {"name": "r_infinity", "units": "dimensionless", "component": "four_AP_sensitive_currents_r_gate"}, {"name": "P_a", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current"}, - {"name": "P_af_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate"}, {"name": "tau_P_af", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate"}, - {"name": "P_as_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"name": "P_af_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_af_gate"}, {"name": "tau_P_as", "units": "second", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate"}, + {"name": "P_as_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_as_gate"}, {"name": "P_i_infinity", "units": "dimensionless", "component": "rapid_delayed_rectifying_potassium_current_P_i_gate"}, - {"name": "alpha_xs", "units": "per_second", "component": "slow_delayed_rectifying_potassium_current_xs_gate"}, {"name": "beta_xs", "units": "per_second", "component": "slow_delayed_rectifying_potassium_current_xs_gate"}, - {"name": "alpha_y", "units": "per_second", "component": "hyperpolarisation_activated_current_y_gate"}, - {"name": "beta_y", "units": "per_second", "component": "hyperpolarisation_activated_current_y_gate"} + {"name": "alpha_xs", "units": "per_second", "component": "slow_delayed_rectifying_potassium_current_xs_gate"}, + {"name": "beta_y", "units": "per_second", "component": "hyperpolarisation_activated_current_y_gate"}, + {"name": "alpha_y", "units": "per_second", "component": "hyperpolarisation_activated_current_y_gate"} ] @@ -254,17 +254,17 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = -39.013558536 states[1] = 0.092361701692 - states[2] = 0.015905380261 - states[3] = 0.01445216109 - states[4] = 0.48779845203 - states[5] = 0.04804900895 + states[2] = 0.01445216109 + states[3] = 0.015905380261 + states[4] = 0.04804900895 + states[5] = 0.48779845203 states[6] = 0.038968420558 states[7] = 0.42074047435 states[8] = 0.064402950262 states[9] = 0.29760539675 states[10] = 0.87993375273 - states[11] = 0.13034201158 - states[12] = 0.46960956028 + states[11] = 0.46960956028 + states[12] = 0.13034201158 states[13] = 0.082293827208 states[14] = 0.03889291759 constants[0] = 0.0 @@ -300,11 +300,11 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic constants[30] = 2.7229e-6 constants[31] = 8.83584e-6 constants[32] = 8.0 - constants[33] = 0.5 - constants[34] = 2.0 - constants[35] = 140.0 + constants[33] = 2.0 + constants[34] = 140.0 + constants[35] = 0.0001 constants[36] = 0.0001 - constants[37] = 0.0001 + constants[37] = 0.5 constants[38] = 0.0478 constants[39] = 0.16 constants[40] = 0.0478 @@ -388,11 +388,11 @@ def compute_computed_constants(constants, computed_constants): computed_constants[9] = constants[26]+computed_constants[0]*(constants[27]-constants[26]) if eq_func(constants[1], 0.0) else constants[30]+computed_constants[0]*(constants[31]-constants[30]) if eq_func(constants[1], 1.0) else constants[28]+computed_constants[0]*(constants[29]-constants[28]) computed_constants[10] = constants[38]+computed_constants[0]*(constants[39]-constants[38]) if eq_func(constants[1], 0.0) else constants[42]+computed_constants[0]*(constants[43]-constants[42]) if eq_func(constants[1], 1.0) else constants[40]+computed_constants[0]*(constants[41]-constants[40]) computed_constants[11] = constants[47]+computed_constants[0]*(constants[48]-constants[47]) if eq_func(constants[1], 0.0) else constants[51]+computed_constants[0]*(constants[52]-constants[51]) if eq_func(constants[1], 1.0) else constants[49]+computed_constants[0]*(constants[50]-constants[49]) - computed_constants[2] = computed_constants[11]*constants[36]/(constants[36]+0.0004) - computed_constants[4] = constants[5]*constants[6]/constants[7]*log(constants[35]/constants[32]) + computed_constants[2] = computed_constants[11]*constants[35]/(constants[35]+0.0004) + computed_constants[4] = constants[5]*constants[6]/constants[7]*log(constants[34]/constants[32]) computed_constants[6] = constants[5]*constants[6]/constants[7]*log(constants[44]/constants[53]) - computed_constants[8] = constants[5]*constants[6]/(2.0*constants[7])*log(constants[34]/constants[36]) - computed_constants[12] = constants[5]*constants[6]/constants[7]*log((constants[44]+0.12*constants[35])/(constants[53]+0.12*constants[32])) if eq_func(constants[1], 0.0) else constants[5]*constants[6]/constants[7]*log((constants[44]+0.03*constants[35])/(constants[53]+0.03*constants[32])) + computed_constants[8] = constants[5]*constants[6]/(2.0*constants[7])*log(constants[33]/constants[35]) + computed_constants[12] = constants[5]*constants[6]/constants[7]*log((constants[44]+0.12*constants[34])/(constants[53]+0.12*constants[32])) if eq_func(constants[1], 0.0) else constants[5]*constants[6]/constants[7]*log((constants[44]+0.03*constants[34])/(constants[53]+0.03*constants[32])) computed_constants[13] = constants[54]+computed_constants[0]*(constants[55]-constants[54]) if eq_func(constants[1], 0.0) else constants[58]+computed_constants[0]*(constants[59]-constants[58]) if eq_func(constants[1], 1.0) else constants[56]+computed_constants[0]*(constants[57]-constants[56]) computed_constants[14] = constants[60]+computed_constants[0]*(constants[61]-constants[60]) if eq_func(constants[1], 0.0) else constants[64]+computed_constants[0]*(constants[65]-constants[64]) if eq_func(constants[1], 1.0) else constants[62]+computed_constants[0]*(constants[63]-constants[62]) computed_constants[15] = constants[67]+computed_constants[0]*(constants[68]-constants[67]) if eq_func(constants[1], 0.0) else constants[71]+computed_constants[0]*(constants[72]-constants[71]) if eq_func(constants[1], 1.0) else constants[69]+computed_constants[0]*(constants[70]-constants[69]) @@ -406,125 +406,125 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) - algebraic[2] = computed_constants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.0374*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.03743*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))) - algebraic[6] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) - algebraic[7] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) - algebraic[8] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) - algebraic[10] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) - algebraic[11] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) - algebraic[12] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) - algebraic[13] = computed_constants[14]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) + algebraic[0] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) + algebraic[1] = computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) + algebraic[5] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) + algebraic[6] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) + algebraic[7] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) + algebraic[9] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) + algebraic[10] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) + algebraic[11] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) + algebraic[12] = computed_constants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) + algebraic[2] = computed_constants[5]*(states[0]-computed_constants[6]) + algebraic[3] = computed_constants[7]*(states[0]-computed_constants[8]) + algebraic[4] = computed_constants[3]*(states[0]-computed_constants[4]) + algebraic[42] = 0.6*states[12]+0.4*states[11] + algebraic[8] = computed_constants[18]*algebraic[42]*states[10]*(states[0]-computed_constants[6]) algebraic[17] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[1], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 - algebraic[14] = (1.0-algebraic[17])*states[2]+algebraic[17]*states[3] - algebraic[0] = computed_constants[13]*pow(states[1], 3.0)*algebraic[14]*constants[35]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] - algebraic[3] = computed_constants[5]*(states[0]-computed_constants[6]) - algebraic[4] = computed_constants[7]*(states[0]-computed_constants[8]) - algebraic[5] = computed_constants[3]*(states[0]-computed_constants[4]) - algebraic[42] = 0.6*states[11]+0.4*states[12] - algebraic[9] = computed_constants[18]*algebraic[42]*states[10]*(states[0]-computed_constants[6]) - rates[0] = -1.0/computed_constants[1]*(algebraic[0]+algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+algebraic[8]+algebraic[7]+algebraic[6]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[2]+algebraic[1]+computed_constants[2]) - algebraic[15] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) - algebraic[16] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 - rates[1] = (algebraic[15]-states[1])/algebraic[16] - algebraic[18] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) - algebraic[19] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 - rates[2] = (algebraic[18]-states[2])/algebraic[19] - algebraic[20] = algebraic[18] - algebraic[21] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 - rates[3] = (algebraic[20]-states[3])/algebraic[21] - algebraic[22] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) - algebraic[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) + algebraic[14] = (1.0-algebraic[17])*states[3]+algebraic[17]*states[2] + algebraic[13] = computed_constants[13]*pow(states[1], 3.0)*algebraic[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] + rates[0] = -1.0/computed_constants[1]*(algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+algebraic[8]+algebraic[7]+algebraic[6]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[2]+algebraic[1]+algebraic[0]+computed_constants[2]) + algebraic[15] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 + algebraic[16] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) + rates[1] = (algebraic[16]-states[1])/algebraic[15] + algebraic[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 + algebraic[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) + rates[3] = (algebraic[19]-states[3])/algebraic[18] + algebraic[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 + algebraic[21] = algebraic[19] + rates[2] = (algebraic[21]-states[2])/algebraic[20] algebraic[25] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[1], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) - algebraic[23] = 2.0/(algebraic[24]+algebraic[25]) - rates[5] = (algebraic[22]-states[5])/algebraic[23] - algebraic[26] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) - algebraic[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) + algebraic[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) + algebraic[22] = 2.0/(algebraic[24]+algebraic[25]) + algebraic[23] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) + rates[4] = (algebraic[23]-states[4])/algebraic[22] algebraic[29] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) - algebraic[27] = (1.2-0.2*computed_constants[0])/(algebraic[28]+algebraic[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraic[28]+algebraic[29]) - rates[4] = (algebraic[26]-states[4])/algebraic[27] - algebraic[30] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) - algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0) + algebraic[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) + algebraic[26] = (1.2-0.2*computed_constants[0])/(algebraic[28]+algebraic[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraic[28]+algebraic[29]) + algebraic[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) + rates[5] = (algebraic[27]-states[5])/algebraic[26] algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0) - algebraic[31] = 1.0/(algebraic[32]+algebraic[33]) - rates[7] = (algebraic[30]-states[7])/algebraic[31] - algebraic[34] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) - algebraic[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) + algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0) + algebraic[30] = 1.0/(algebraic[32]+algebraic[33]) + algebraic[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) + rates[7] = (algebraic[31]-states[7])/algebraic[30] algebraic[37] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[1], 1.0) else 15.0*exp((states[0]+71.7)/15.38) - algebraic[35] = 1.0/(algebraic[36]+algebraic[37]) - rates[6] = (algebraic[34]-states[6])/algebraic[35] - algebraic[38] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) - algebraic[39] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) - rates[9] = (algebraic[38]-states[9])/algebraic[39] - algebraic[40] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) - algebraic[41] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) - rates[8] = (algebraic[40]-states[8])/algebraic[41] - algebraic[43] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) - algebraic[44] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) - rates[11] = (algebraic[43]-states[11])/algebraic[44] - algebraic[45] = algebraic[43] - algebraic[46] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) - rates[12] = (algebraic[45]-states[12])/algebraic[46] + algebraic[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) + algebraic[34] = 1.0/(algebraic[36]+algebraic[37]) + algebraic[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) + rates[6] = (algebraic[35]-states[6])/algebraic[34] + algebraic[38] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) + algebraic[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) + rates[9] = (algebraic[39]-states[9])/algebraic[38] + algebraic[40] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) + algebraic[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) + rates[8] = (algebraic[41]-states[8])/algebraic[40] + algebraic[43] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) + algebraic[44] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) + rates[12] = (algebraic[44]-states[12])/algebraic[43] + algebraic[45] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) + algebraic[46] = algebraic[44] + rates[11] = (algebraic[46]-states[11])/algebraic[45] algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) rates[10] = (algebraic[47]-states[10])/computed_constants[19] - algebraic[48] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) - algebraic[49] = 1.0*exp(-states[0]/45.0) - rates[13] = algebraic[48]*(1.0-states[13])-algebraic[49]*states[13] - algebraic[50] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) - algebraic[51] = 1.0*exp((states[0]+75.13)/21.25) - rates[14] = algebraic[50]*(1.0-states[14])-algebraic[51]*states[14] + algebraic[48] = 1.0*exp(-states[0]/45.0) + algebraic[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) + rates[13] = algebraic[49]*(1.0-states[13])-algebraic[48]*states[13] + algebraic[50] = 1.0*exp((states[0]+75.13)/21.25) + algebraic[51] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) + rates[14] = algebraic[51]*(1.0-states[14])-algebraic[50]*states[14] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[5] = computed_constants[3]*(states[0]-computed_constants[4]) - algebraic[3] = computed_constants[5]*(states[0]-computed_constants[6]) - algebraic[4] = computed_constants[7]*(states[0]-computed_constants[8]) - algebraic[2] = computed_constants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.0374*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[34]*exp(0.03743*states[0]*constants[33])-pow(constants[35], 3.0)*constants[36]*exp(0.03743*states[0]*(constants[33]-1.0)))/(1.0+constants[37]*(constants[36]*pow(constants[35], 3.0)+constants[34]*pow(constants[32], 3.0))) - algebraic[1] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) + algebraic[4] = computed_constants[3]*(states[0]-computed_constants[4]) + algebraic[2] = computed_constants[5]*(states[0]-computed_constants[6]) + algebraic[3] = computed_constants[7]*(states[0]-computed_constants[8]) + algebraic[1] = computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) + algebraic[0] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) algebraic[17] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[1], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 - algebraic[14] = (1.0-algebraic[17])*states[2]+algebraic[17]*states[3] - algebraic[0] = computed_constants[13]*pow(states[1], 3.0)*algebraic[14]*constants[35]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] - algebraic[15] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) - algebraic[16] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 - algebraic[18] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) - algebraic[20] = algebraic[18] - algebraic[19] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 - algebraic[21] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 - algebraic[13] = computed_constants[14]*(states[4]*states[5]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) + algebraic[14] = (1.0-algebraic[17])*states[3]+algebraic[17]*states[2] + algebraic[13] = computed_constants[13]*pow(states[1], 3.0)*algebraic[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] + algebraic[16] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) + algebraic[15] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 + algebraic[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) + algebraic[21] = algebraic[19] + algebraic[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 + algebraic[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 + algebraic[12] = computed_constants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) algebraic[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) algebraic[25] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[1], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) - algebraic[23] = 2.0/(algebraic[24]+algebraic[25]) - algebraic[22] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) + algebraic[22] = 2.0/(algebraic[24]+algebraic[25]) + algebraic[23] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) algebraic[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) algebraic[29] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) - algebraic[27] = (1.2-0.2*computed_constants[0])/(algebraic[28]+algebraic[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraic[28]+algebraic[29]) - algebraic[26] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) - algebraic[12] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) + algebraic[26] = (1.2-0.2*computed_constants[0])/(algebraic[28]+algebraic[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraic[28]+algebraic[29]) + algebraic[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) + algebraic[11] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0) algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0) - algebraic[31] = 1.0/(algebraic[32]+algebraic[33]) - algebraic[30] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) + algebraic[30] = 1.0/(algebraic[32]+algebraic[33]) + algebraic[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) algebraic[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) algebraic[37] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[1], 1.0) else 15.0*exp((states[0]+71.7)/15.38) - algebraic[35] = 1.0/(algebraic[36]+algebraic[37]) - algebraic[34] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) - algebraic[11] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) - algebraic[10] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) - algebraic[38] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) - algebraic[39] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) - algebraic[40] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) - algebraic[41] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) - algebraic[42] = 0.6*states[11]+0.4*states[12] - algebraic[9] = computed_constants[18]*algebraic[42]*states[10]*(states[0]-computed_constants[6]) - algebraic[43] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) - algebraic[44] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) - algebraic[45] = algebraic[43] - algebraic[46] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) + algebraic[34] = 1.0/(algebraic[36]+algebraic[37]) + algebraic[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) + algebraic[10] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) + algebraic[9] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) + algebraic[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) + algebraic[38] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) + algebraic[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) + algebraic[40] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) + algebraic[42] = 0.6*states[12]+0.4*states[11] + algebraic[8] = computed_constants[18]*algebraic[42]*states[10]*(states[0]-computed_constants[6]) + algebraic[44] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) + algebraic[43] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) + algebraic[46] = algebraic[44] + algebraic[45] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) - algebraic[8] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) - algebraic[48] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) - algebraic[49] = 1.0*exp(-states[0]/45.0) - algebraic[7] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) - algebraic[6] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) - algebraic[50] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) - algebraic[51] = 1.0*exp((states[0]+75.13)/21.25) + algebraic[7] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) + algebraic[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) + algebraic[48] = 1.0*exp(-states[0]/45.0) + algebraic[6] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) + algebraic[5] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) + algebraic[51] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) + algebraic[50] = 1.0*exp((states[0]+75.13)/21.25) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 75e213725..57bd1e9b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -140,14 +140,14 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[4] = 4.0*exp(states[0]/18.0); + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2]; - algebraic[5] = 0.07*exp(states[0]/20.0); algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[5] = 0.07*exp(states[0]/20.0); rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1]; - algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[8] = 0.125*exp(states[0]/80.0); + algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); rates[3] = algebraic[7]*(1.0-states[3])-algebraic[8]*states[3]; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 53b625d36..f4db29b48 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -109,14 +109,14 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0] - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[4] = 4.0*exp(states[0]/18.0) + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2] - algebraic[5] = 0.07*exp(states[0]/20.0) algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[5] = 0.07*exp(states[0]/20.0) rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1] - algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[8] = 0.125*exp(states[0]/80.0) + algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) rates[3] = algebraic[7]*(1.0-states[3])-algebraic[8]*states[3] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 0f3d5ef29..20f5f4984 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -125,14 +125,14 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; - algebraic[6] = 0.07*exp(states[0]/20.0); algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[6] = 0.07*exp(states[0]/20.0); rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(states[0]/80.0); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index af7e376e2..99dc6070b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -140,14 +140,14 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; - algebraic[6] = 0.07*exp(states[0]/20.0); algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[6] = 0.07*exp(states[0]/20.0); rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(states[0]/80.0); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 67b3cc73c..ed84c115a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -109,14 +109,14 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] - algebraic[6] = 0.07*exp(states[0]/20.0) algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[6] = 0.07*exp(states[0]/20.0) rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(states[0]/80.0) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 05260ea3f..e5a9fe969 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -134,20 +134,20 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); + algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0]; - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; - algebraic[6] = 0.07*exp(states[0]/20.0); algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[6] = 0.07*exp(states[0]/20.0); rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(states[0]/80.0); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index de7ac2357..1352b3614 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -103,20 +103,20 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) + algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0] - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] - algebraic[6] = 0.07*exp(states[0]/20.0) algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[6] = 0.07*exp(states[0]/20.0) rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(states[0]/80.0) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 5fdd4779b..88b12957e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -591,16 +591,16 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraic); findRoot2(voi, states, rates, constants, computedConstants, algebraic); findRoot3(voi, states, rates, constants, computedConstants, algebraic); - findRoot14(voi, states, rates, constants, computedConstants, algebraic); findRoot15(voi, states, rates, constants, computedConstants, algebraic); + findRoot14(voi, states, rates, constants, computedConstants, algebraic); findRoot16(voi, states, rates, constants, computedConstants, algebraic); findRoot12(voi, states, rates, constants, computedConstants, algebraic); findRoot13(voi, states, rates, constants, computedConstants, algebraic); - findRoot9(voi, states, rates, constants, computedConstants, algebraic); findRoot10(voi, states, rates, constants, computedConstants, algebraic); + findRoot9(voi, states, rates, constants, computedConstants, algebraic); findRoot11(voi, states, rates, constants, computedConstants, algebraic); - findRoot6(voi, states, rates, constants, computedConstants, algebraic); findRoot7(voi, states, rates, constants, computedConstants, algebraic); + findRoot6(voi, states, rates, constants, computedConstants, algebraic); findRoot8(voi, states, rates, constants, computedConstants, algebraic); findRoot4(voi, states, rates, constants, computedConstants, algebraic); findRoot5(voi, states, rates, constants, computedConstants, algebraic); @@ -612,16 +612,16 @@ void computeVariables(double voi, double *states, double *rates, double *constan findRoot0(voi, states, rates, constants, computedConstants, algebraic); findRoot2(voi, states, rates, constants, computedConstants, algebraic); findRoot3(voi, states, rates, constants, computedConstants, algebraic); - findRoot14(voi, states, rates, constants, computedConstants, algebraic); findRoot15(voi, states, rates, constants, computedConstants, algebraic); + findRoot14(voi, states, rates, constants, computedConstants, algebraic); findRoot16(voi, states, rates, constants, computedConstants, algebraic); findRoot12(voi, states, rates, constants, computedConstants, algebraic); findRoot13(voi, states, rates, constants, computedConstants, algebraic); - findRoot9(voi, states, rates, constants, computedConstants, algebraic); findRoot10(voi, states, rates, constants, computedConstants, algebraic); + findRoot9(voi, states, rates, constants, computedConstants, algebraic); findRoot11(voi, states, rates, constants, computedConstants, algebraic); - findRoot6(voi, states, rates, constants, computedConstants, algebraic); findRoot7(voi, states, rates, constants, computedConstants, algebraic); + findRoot6(voi, states, rates, constants, computedConstants, algebraic); findRoot8(voi, states, rates, constants, computedConstants, algebraic); findRoot4(voi, states, rates, constants, computedConstants, algebraic); findRoot5(voi, states, rates, constants, computedConstants, algebraic); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c index bacce2ba8..58b1f19bd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c @@ -48,8 +48,8 @@ const VariableInfo ALGEBRAIC_INFO[] = { }; const VariableInfo EXTERNAL_INFO[] = { - {"V", "millivolt", "membrane"}, {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"V", "millivolt", "membrane"}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate"} }; @@ -192,7 +192,7 @@ void objectiveFunction3(double *u, double *f, void *data) algebraic[1] = u[0]; - f[0] = algebraic[1]-constants[2]*(externals[0]-algebraic[3])-0.0; + f[0] = algebraic[1]-constants[2]*(externals[1]-algebraic[3])-0.0; } void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) @@ -246,7 +246,7 @@ void objectiveFunction6(double *u, double *f, void *data) algebraic[5] = u[0]; - f[0] = algebraic[5]-0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0)-0.0; + f[0] = algebraic[5]-0.1*(externals[1]+25.0)/(exp((externals[1]+25.0)/10.0)-1.0)-0.0; } void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) @@ -273,7 +273,7 @@ void objectiveFunction7(double *u, double *f, void *data) algebraic[6] = u[0]; - f[0] = algebraic[6]-4.0*exp(externals[0]/18.0)-0.0; + f[0] = algebraic[6]-4.0*exp(externals[1]/18.0)-0.0; } void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) @@ -327,7 +327,7 @@ void objectiveFunction9(double *u, double *f, void *data) algebraic[7] = u[0]; - f[0] = algebraic[7]-0.07*exp(externals[0]/20.0)-0.0; + f[0] = algebraic[7]-0.07*exp(externals[1]/20.0)-0.0; } void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) @@ -354,7 +354,7 @@ void objectiveFunction10(double *u, double *f, void *data) algebraic[8] = u[0]; - f[0] = algebraic[8]-1.0/(exp((externals[0]+30.0)/10.0)+1.0)-0.0; + f[0] = algebraic[8]-1.0/(exp((externals[1]+30.0)/10.0)+1.0)-0.0; } void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) @@ -435,7 +435,7 @@ void objectiveFunction13(double *u, double *f, void *data) algebraic[2] = u[0]; - f[0] = algebraic[2]-constants[4]*pow(states[2], 4.0)*(externals[0]-algebraic[9])-0.0; + f[0] = algebraic[2]-constants[4]*pow(states[2], 4.0)*(externals[1]-algebraic[9])-0.0; } void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) @@ -462,7 +462,7 @@ void objectiveFunction15(double *u, double *f, void *data) algebraic[10] = u[0]; - f[0] = algebraic[10]-0.125*exp(externals[0]/80.0)-0.0; + f[0] = algebraic[10]-0.125*exp(externals[1]/80.0)-0.0; } void findRoot15(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) @@ -536,15 +536,15 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - findRoot6(voi, states, rates, constants, computedConstants, algebraic, externals); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); findRoot7(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot6(voi, states, rates, constants, computedConstants, algebraic, externals); findRoot8(voi, states, rates, constants, computedConstants, algebraic, externals); - findRoot9(voi, states, rates, constants, computedConstants, algebraic, externals); findRoot10(voi, states, rates, constants, computedConstants, algebraic, externals); + findRoot9(voi, states, rates, constants, computedConstants, algebraic, externals); findRoot11(voi, states, rates, constants, computedConstants, algebraic, externals); - externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); findRoot15(voi, states, rates, constants, computedConstants, algebraic, externals); + externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); findRoot16(voi, states, rates, constants, computedConstants, algebraic, externals); } @@ -552,11 +552,11 @@ void computeVariables(double voi, double *states, double *rates, double *constan { findRoot0(voi, states, rates, constants, computedConstants, algebraic, externals); findRoot2(voi, states, rates, constants, computedConstants, algebraic, externals); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); findRoot3(voi, states, rates, constants, computedConstants, algebraic, externals); findRoot4(voi, states, rates, constants, computedConstants, algebraic, externals); findRoot12(voi, states, rates, constants, computedConstants, algebraic, externals); findRoot13(voi, states, rates, constants, computedConstants, algebraic, externals); externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py index 76a61944b..bc720ae19 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py @@ -47,8 +47,8 @@ ] EXTERNAL_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] @@ -147,7 +147,7 @@ def objective_function_3(u, f, data): algebraic[1] = u[0] - f[0] = algebraic[1]-constants[2]*(externals[0]-algebraic[3])-0.0 + f[0] = algebraic[1]-constants[2]*(externals[1]-algebraic[3])-0.0 def find_root_3(voi, states, rates, constants, computed_constants, algebraic, externals): @@ -195,7 +195,7 @@ def objective_function_6(u, f, data): algebraic[5] = u[0] - f[0] = algebraic[5]-0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0)-0.0 + f[0] = algebraic[5]-0.1*(externals[1]+25.0)/(exp((externals[1]+25.0)/10.0)-1.0)-0.0 def find_root_6(voi, states, rates, constants, computed_constants, algebraic, externals): @@ -219,7 +219,7 @@ def objective_function_7(u, f, data): algebraic[6] = u[0] - f[0] = algebraic[6]-4.0*exp(externals[0]/18.0)-0.0 + f[0] = algebraic[6]-4.0*exp(externals[1]/18.0)-0.0 def find_root_7(voi, states, rates, constants, computed_constants, algebraic, externals): @@ -267,7 +267,7 @@ def objective_function_9(u, f, data): algebraic[7] = u[0] - f[0] = algebraic[7]-0.07*exp(externals[0]/20.0)-0.0 + f[0] = algebraic[7]-0.07*exp(externals[1]/20.0)-0.0 def find_root_9(voi, states, rates, constants, computed_constants, algebraic, externals): @@ -291,7 +291,7 @@ def objective_function_10(u, f, data): algebraic[8] = u[0] - f[0] = algebraic[8]-1.0/(exp((externals[0]+30.0)/10.0)+1.0)-0.0 + f[0] = algebraic[8]-1.0/(exp((externals[1]+30.0)/10.0)+1.0)-0.0 def find_root_10(voi, states, rates, constants, computed_constants, algebraic, externals): @@ -363,7 +363,7 @@ def objective_function_13(u, f, data): algebraic[2] = u[0] - f[0] = algebraic[2]-constants[4]*pow(states[2], 4.0)*(externals[0]-algebraic[9])-0.0 + f[0] = algebraic[2]-constants[4]*pow(states[2], 4.0)*(externals[1]-algebraic[9])-0.0 def find_root_13(voi, states, rates, constants, computed_constants, algebraic, externals): @@ -387,7 +387,7 @@ def objective_function_15(u, f, data): algebraic[10] = u[0] - f[0] = algebraic[10]-0.125*exp(externals[0]/80.0)-0.0 + f[0] = algebraic[10]-0.125*exp(externals[1]/80.0)-0.0 def find_root_15(voi, states, rates, constants, computed_constants, algebraic, externals): @@ -454,25 +454,25 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - find_root_6(voi, states, rates, constants, computed_constants, algebraic, externals) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) find_root_7(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_6(voi, states, rates, constants, computed_constants, algebraic, externals) find_root_8(voi, states, rates, constants, computed_constants, algebraic, externals) - find_root_9(voi, states, rates, constants, computed_constants, algebraic, externals) find_root_10(voi, states, rates, constants, computed_constants, algebraic, externals) + find_root_9(voi, states, rates, constants, computed_constants, algebraic, externals) find_root_11(voi, states, rates, constants, computed_constants, algebraic, externals) - externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) find_root_15(voi, states, rates, constants, computed_constants, algebraic, externals) + externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) find_root_16(voi, states, rates, constants, computed_constants, algebraic, externals) def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals) find_root_2(voi, states, rates, constants, computed_constants, algebraic, externals) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) find_root_3(voi, states, rates, constants, computed_constants, algebraic, externals) find_root_4(voi, states, rates, constants, computed_constants, algebraic, externals) find_root_12(voi, states, rates, constants, computed_constants, algebraic, externals) find_root_13(voi, states, rates, constants, computed_constants, algebraic, externals) externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index 69e0c05ef..b7305bef5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -508,16 +508,16 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, constants, computed_constants, algebraic) find_root_2(voi, states, rates, constants, computed_constants, algebraic) find_root_3(voi, states, rates, constants, computed_constants, algebraic) - find_root_14(voi, states, rates, constants, computed_constants, algebraic) find_root_15(voi, states, rates, constants, computed_constants, algebraic) + find_root_14(voi, states, rates, constants, computed_constants, algebraic) find_root_16(voi, states, rates, constants, computed_constants, algebraic) find_root_12(voi, states, rates, constants, computed_constants, algebraic) find_root_13(voi, states, rates, constants, computed_constants, algebraic) - find_root_9(voi, states, rates, constants, computed_constants, algebraic) find_root_10(voi, states, rates, constants, computed_constants, algebraic) + find_root_9(voi, states, rates, constants, computed_constants, algebraic) find_root_11(voi, states, rates, constants, computed_constants, algebraic) - find_root_6(voi, states, rates, constants, computed_constants, algebraic) find_root_7(voi, states, rates, constants, computed_constants, algebraic) + find_root_6(voi, states, rates, constants, computed_constants, algebraic) find_root_8(voi, states, rates, constants, computed_constants, algebraic) find_root_4(voi, states, rates, constants, computed_constants, algebraic) find_root_5(voi, states, rates, constants, computed_constants, algebraic) @@ -528,16 +528,16 @@ def compute_variables(voi, states, rates, constants, computed_constants, algebra find_root_0(voi, states, rates, constants, computed_constants, algebraic) find_root_2(voi, states, rates, constants, computed_constants, algebraic) find_root_3(voi, states, rates, constants, computed_constants, algebraic) - find_root_14(voi, states, rates, constants, computed_constants, algebraic) find_root_15(voi, states, rates, constants, computed_constants, algebraic) + find_root_14(voi, states, rates, constants, computed_constants, algebraic) find_root_16(voi, states, rates, constants, computed_constants, algebraic) find_root_12(voi, states, rates, constants, computed_constants, algebraic) find_root_13(voi, states, rates, constants, computed_constants, algebraic) - find_root_9(voi, states, rates, constants, computed_constants, algebraic) find_root_10(voi, states, rates, constants, computed_constants, algebraic) + find_root_9(voi, states, rates, constants, computed_constants, algebraic) find_root_11(voi, states, rates, constants, computed_constants, algebraic) - find_root_6(voi, states, rates, constants, computed_constants, algebraic) find_root_7(voi, states, rates, constants, computed_constants, algebraic) + find_root_6(voi, states, rates, constants, computed_constants, algebraic) find_root_8(voi, states, rates, constants, computed_constants, algebraic) find_root_4(voi, states, rates, constants, computed_constants, algebraic) find_root_5(voi, states, rates, constants, computed_constants, algebraic) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index a9a552c8b..a6fb8af51 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -141,11 +141,11 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[4] = 4.0*exp(states[0]/18.0); + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2]; - algebraic[5] = 0.07*exp(states[0]/20.0); algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[5] = 0.07*exp(states[0]/20.0); rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1]; algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); rates[3] = algebraic[7]*(1.0-states[3])-externals[1]*states[3]; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 83626beeb..6638e4592 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -110,11 +110,11 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0] - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[4] = 4.0*exp(states[0]/18.0) + algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2] - algebraic[5] = 0.07*exp(states[0]/20.0) algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[5] = 0.07*exp(states[0]/20.0) rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1] algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) rates[3] = algebraic[7]*(1.0-states[3])-externals[1]*states[3] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index c592108ef..78b3bd99c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -140,14 +140,14 @@ void computeRates(double voi, double *states, double *rates, double *constants, algebraic[5] = externals[0]-115.0; algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[7] = 4.0*exp(states[0]/18.0); + algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2]; - algebraic[8] = 0.07*exp(states[0]/20.0); algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[8] = 0.07*exp(states[0]/20.0); rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1]; - algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[11] = 0.125*exp(states[0]/80.0); + algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3]; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 4da78587b..8e963aa09 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -110,14 +110,14 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, algebraic[5] = externals[0]-115.0 algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[7] = 4.0*exp(states[0]/18.0) + algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2] - algebraic[8] = 0.07*exp(states[0]/20.0) algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[8] = 0.07*exp(states[0]/20.0) rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1] - algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[11] = 0.125*exp(states[0]/80.0) + algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 2f8359b0b..a7c155dfb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -133,21 +133,21 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); + algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; algebraic[1] = constants[1]*(states[0]-computedConstants[0]); algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0]; - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraic[5] = 4.0*exp(states[0]/18.0); + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; - algebraic[6] = 0.07*exp(states[0]/20.0); algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[6] = 0.07*exp(states[0]/20.0); rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(states[0]/80.0); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index d24df5195..3e25d4379 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -102,21 +102,21 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) + algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 algebraic[1] = constants[1]*(states[0]-computed_constants[0]) algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0] - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] - algebraic[6] = 0.07*exp(states[0]/20.0) algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[6] = 0.07*exp(states[0]/20.0) rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(states[0]/80.0) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index a363a047e..7c8888dc4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -134,11 +134,11 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[6] = 0.07*exp(externals[0]/20.0); algebraic[7] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0); + algebraic[6] = 0.07*exp(externals[0]/20.0); rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0]; - algebraic[8] = 0.01*(externals[0]+10.0)/(exp((externals[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(externals[0]/80.0); + algebraic[8] = 0.01*(externals[0]+10.0)/(exp((externals[0]+10.0)/10.0)-1.0); rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1]; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 6c333b8b4..96d1a9ad3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -103,11 +103,11 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[6] = 0.07*exp(externals[0]/20.0) algebraic[7] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0) + algebraic[6] = 0.07*exp(externals[0]/20.0) rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0] - algebraic[8] = 0.01*(externals[0]+10.0)/(exp((externals[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(externals[0]/80.0) + algebraic[8] = 0.01*(externals[0]+10.0)/(exp((externals[0]+10.0)/10.0)-1.0) rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 1299c63b4..048289ae0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -48,8 +48,8 @@ const VariableInfo ALGEBRAIC_INFO[] = { }; const VariableInfo EXTERNAL_INFO[] = { - {"V", "millivolt", "membrane"}, {"i_Na", "microA_per_cm2", "sodium_channel"}, + {"V", "millivolt", "membrane"}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate"} }; @@ -134,24 +134,24 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[3] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0); - algebraic[4] = 4.0*exp(externals[0]/18.0); + externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); + algebraic[4] = 4.0*exp(externals[1]/18.0); + algebraic[3] = 0.1*(externals[1]+25.0)/(exp((externals[1]+25.0)/10.0)-1.0); rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1]; - algebraic[5] = 0.07*exp(externals[0]/20.0); - algebraic[6] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0); + algebraic[6] = 1.0/(exp((externals[1]+30.0)/10.0)+1.0); + algebraic[5] = 0.07*exp(externals[1]/20.0); rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0]; + algebraic[7] = 0.125*exp(externals[1]/80.0); externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); - algebraic[7] = 0.125*exp(externals[0]/80.0); rates[2] = externals[2]*(1.0-states[2])-algebraic[7]*states[2]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[1] = constants[2]*(externals[0]-computedConstants[0]); - externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[0]-computedConstants[2]); + algebraic[1] = constants[2]*(externals[1]-computedConstants[0]); + externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); + externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); + algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[1]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 0964000c3..2e2867ca2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -47,8 +47,8 @@ ] EXTERNAL_INFO = [ - {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, + {"name": "V", "units": "millivolt", "component": "membrane"}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] @@ -103,22 +103,22 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[3] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0) - algebraic[4] = 4.0*exp(externals[0]/18.0) + externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) + algebraic[4] = 4.0*exp(externals[1]/18.0) + algebraic[3] = 0.1*(externals[1]+25.0)/(exp((externals[1]+25.0)/10.0)-1.0) rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1] - algebraic[5] = 0.07*exp(externals[0]/20.0) - algebraic[6] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0) + algebraic[6] = 1.0/(exp((externals[1]+30.0)/10.0)+1.0) + algebraic[5] = 0.07*exp(externals[1]/20.0) rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0] + algebraic[7] = 0.125*exp(externals[1]/80.0) externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) - algebraic[7] = 0.125*exp(externals[0]/80.0) rates[2] = externals[2]*(1.0-states[2])-algebraic[7]*states[2] def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[1] = constants[2]*(externals[0]-computed_constants[0]) - externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[0]-computed_constants[2]) + algebraic[1] = constants[2]*(externals[1]-computed_constants[0]) + externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) + externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) + algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[1]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 07ee1723c..eddf909c6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -101,14 +101,14 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic): algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic[5] = 4.0*exp(states[0]/18.0) + algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] - algebraic[6] = 0.07*exp(states[0]/20.0) algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[6] = 0.07*exp(states[0]/20.0) rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(states[0]/80.0) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index d465e1ab9..976f72c4b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -140,11 +140,11 @@ void computeRates(double voi, double *states, double *rates, double *constants, externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computedConstants[1]); rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[6] = 0.07*exp(states[0]/20.0); algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraic[6] = 0.07*exp(states[0]/20.0); rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); algebraic[9] = 0.125*exp(states[0]/80.0); + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); rates[2] = algebraic[8]*(1.0-states[2])-algebraic[9]*states[2]; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 0940318f8..4b6c7b26c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -109,11 +109,11 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computed_constants[1]) rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[6] = 0.07*exp(states[0]/20.0) algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraic[6] = 0.07*exp(states[0]/20.0) rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) algebraic[9] = 0.125*exp(states[0]/80.0) + algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) rates[2] = algebraic[8]*(1.0-states[2])-algebraic[9]*states[2] diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index f9986d0e4..8fa658f0c 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -17,15 +17,15 @@ const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; const VariableInfo STATE_INFO[] = { {"V", "millivolt", "membrane"}, - {"m", "dimensionless", "sodium_channel_m_gate"}, {"h", "dimensionless", "sodium_channel_h_gate"}, + {"m", "dimensionless", "sodium_channel_m_gate"}, {"n", "dimensionless", "potassium_channel_n_gate"} }; const VariableInfo CONSTANT_INFO[] = { {"Cm", "microF_per_cm2", "membrane"}, - {"g_L", "milliS_per_cm2", "leakage_current"}, {"E_L", "millivolt", "leakage_current"}, + {"g_L", "milliS_per_cm2", "leakage_current"}, {"g_Na_max", "milliS_per_cm2", "sodium_channel"}, {"E_Na", "millivolt", "sodium_channel"} }; @@ -34,16 +34,16 @@ const VariableInfo COMPUTED_CONSTANT_INFO[] = { }; const VariableInfo ALGEBRAIC_INFO[] = { - {"i_Na", "microA_per_cm2", "sodium_channel"}, {"i_Leak", "microA_per_cm2", "leakage_current"}, {"i_K", "microA_per_cm2", "potassium_channel"}, + {"i_Na", "microA_per_cm2", "sodium_channel"}, {"g_Na", "milliS_per_cm2", "sodium_channel"}, {"alpha_m", "per_millisecond", "sodium_channel_m_gate"}, {"beta_m", "per_millisecond", "sodium_channel_m_gate"}, {"alpha_h", "per_millisecond", "sodium_channel_h_gate"}, {"beta_h", "per_millisecond", "sodium_channel_h_gate"}, - {"g_K1", "milliS_per_cm2", "potassium_channel"}, {"g_K2", "milliS_per_cm2", "potassium_channel"}, + {"g_K1", "milliS_per_cm2", "potassium_channel"}, {"alpha_n", "per_millisecond", "potassium_channel_n_gate"}, {"beta_n", "per_millisecond", "potassium_channel_n_gate"} }; @@ -100,12 +100,12 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { states[0] = -87.0; - states[1] = 0.01; - states[2] = 0.8; + states[1] = 0.8; + states[2] = 0.01; states[3] = 0.01; constants[0] = 12.0; - constants[1] = 0.075; - constants[2] = -60.0; + constants[1] = -60.0; + constants[2] = 0.075; constants[3] = 400.0; constants[4] = 40.0; } @@ -116,36 +116,36 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[3] = pow(states[1], 3.0)*states[2]*constants[3]; - algebraic[0] = (algebraic[3]+0.14)*(states[0]-constants[4]); - algebraic[1] = constants[1]*(states[0]-constants[2]); - algebraic[8] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); - algebraic[9] = 1.2*pow(states[3], 4.0); - algebraic[2] = (algebraic[8]+algebraic[9])*(states[0]+100.0); - rates[0] = -(algebraic[0]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); + algebraic[0] = constants[2]*(states[0]-constants[1]); + algebraic[3] = pow(states[2], 3.0)*states[1]*constants[3]; + algebraic[2] = (algebraic[3]+0.14)*(states[0]-constants[4]); + algebraic[8] = 1.2*pow(states[3], 4.0); + algebraic[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); + algebraic[1] = (algebraic[9]+algebraic[8])*(states[0]+100.0); + rates[0] = -(algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); - rates[1] = algebraic[4]*(1.0-states[1])-algebraic[5]*states[1]; - algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0); + algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); - rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2]; - algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); + algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0); + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0); + algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[1] = constants[1]*(states[0]-constants[2]); - algebraic[3] = pow(states[1], 3.0)*states[2]*constants[3]; - algebraic[0] = (algebraic[3]+0.14)*(states[0]-constants[4]); + algebraic[0] = constants[2]*(states[0]-constants[1]); + algebraic[3] = pow(states[2], 3.0)*states[1]*constants[3]; + algebraic[2] = (algebraic[3]+0.14)*(states[0]-constants[4]); algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0); algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); - algebraic[8] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); - algebraic[9] = 1.2*pow(states[3], 4.0); - algebraic[2] = (algebraic[8]+algebraic[9])*(states[0]+100.0); + algebraic[8] = 1.2*pow(states[3], 4.0); + algebraic[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); + algebraic[1] = (algebraic[9]+algebraic[8])*(states[0]+100.0); algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0); } diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 63f4abd61..7d7234738 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -16,15 +16,15 @@ STATE_INFO = [ {"name": "V", "units": "millivolt", "component": "membrane"}, - {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "h", "units": "dimensionless", "component": "sodium_channel_h_gate"}, + {"name": "m", "units": "dimensionless", "component": "sodium_channel_m_gate"}, {"name": "n", "units": "dimensionless", "component": "potassium_channel_n_gate"} ] CONSTANT_INFO = [ {"name": "Cm", "units": "microF_per_cm2", "component": "membrane"}, - {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, {"name": "E_L", "units": "millivolt", "component": "leakage_current"}, + {"name": "g_L", "units": "milliS_per_cm2", "component": "leakage_current"}, {"name": "g_Na_max", "units": "milliS_per_cm2", "component": "sodium_channel"}, {"name": "E_Na", "units": "millivolt", "component": "sodium_channel"} ] @@ -33,16 +33,16 @@ ] ALGEBRAIC_INFO = [ - {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, {"name": "i_Leak", "units": "microA_per_cm2", "component": "leakage_current"}, {"name": "i_K", "units": "microA_per_cm2", "component": "potassium_channel"}, + {"name": "i_Na", "units": "microA_per_cm2", "component": "sodium_channel"}, {"name": "g_Na", "units": "milliS_per_cm2", "component": "sodium_channel"}, {"name": "alpha_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, {"name": "beta_m", "units": "per_millisecond", "component": "sodium_channel_m_gate"}, {"name": "alpha_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, {"name": "beta_h", "units": "per_millisecond", "component": "sodium_channel_h_gate"}, - {"name": "g_K1", "units": "milliS_per_cm2", "component": "potassium_channel"}, {"name": "g_K2", "units": "milliS_per_cm2", "component": "potassium_channel"}, + {"name": "g_K1", "units": "milliS_per_cm2", "component": "potassium_channel"}, {"name": "alpha_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"}, {"name": "beta_n", "units": "per_millisecond", "component": "potassium_channel_n_gate"} ] @@ -66,12 +66,12 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, computed_constants, algebraic): states[0] = -87.0 - states[1] = 0.01 - states[2] = 0.8 + states[1] = 0.8 + states[2] = 0.01 states[3] = 0.01 constants[0] = 12.0 - constants[1] = 0.075 - constants[2] = -60.0 + constants[1] = -60.0 + constants[2] = 0.075 constants[3] = 400.0 constants[4] = 40.0 @@ -81,34 +81,34 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[3] = pow(states[1], 3.0)*states[2]*constants[3] - algebraic[0] = (algebraic[3]+0.14)*(states[0]-constants[4]) - algebraic[1] = constants[1]*(states[0]-constants[2]) - algebraic[8] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) - algebraic[9] = 1.2*pow(states[3], 4.0) - algebraic[2] = (algebraic[8]+algebraic[9])*(states[0]+100.0) - rates[0] = -(algebraic[0]+algebraic[2]+algebraic[1])/constants[0] - algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) + algebraic[0] = constants[2]*(states[0]-constants[1]) + algebraic[3] = pow(states[2], 3.0)*states[1]*constants[3] + algebraic[2] = (algebraic[3]+0.14)*(states[0]-constants[4]) + algebraic[8] = 1.2*pow(states[3], 4.0) + algebraic[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) + algebraic[1] = (algebraic[9]+algebraic[8])*(states[0]+100.0) + rates[0] = -(algebraic[2]+algebraic[1]+algebraic[0])/constants[0] algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) - rates[1] = algebraic[4]*(1.0-states[1])-algebraic[5]*states[1] - algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0) + algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) + rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) - rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2] - algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) + algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0) + rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0) + algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = constants[1]*(states[0]-constants[2]) - algebraic[3] = pow(states[1], 3.0)*states[2]*constants[3] - algebraic[0] = (algebraic[3]+0.14)*(states[0]-constants[4]) + algebraic[0] = constants[2]*(states[0]-constants[1]) + algebraic[3] = pow(states[2], 3.0)*states[1]*constants[3] + algebraic[2] = (algebraic[3]+0.14)*(states[0]-constants[4]) algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0) algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) - algebraic[8] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) - algebraic[9] = 1.2*pow(states[3], 4.0) - algebraic[2] = (algebraic[8]+algebraic[9])*(states[0]+100.0) + algebraic[8] = 1.2*pow(states[3], 4.0) + algebraic[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) + algebraic[1] = (algebraic[9]+algebraic[8])*(states[0]+100.0) algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0) diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index ab0872c8d..595ee1270 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -16,8 +16,8 @@ const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_x_ode"}, - {"y", "dimensionless", "my_y_ode"} + {"y", "dimensionless", "my_y_ode"}, + {"x", "dimensionless", "my_x_ode"} }; const VariableInfo CONSTANT_INFO[] = { @@ -81,8 +81,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - states[0] = -2.0; - states[1] = 0.0; + states[0] = 0.0; + states[1] = -2.0; constants[0] = 1.0; } @@ -92,8 +92,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = states[1]*1.0; - rates[1] = (constants[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0; + rates[1] = states[0]*1.0; + rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index cc86016f3..8887ccf68 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -15,8 +15,8 @@ VOI_INFO = {"name": "t", "units": "second", "component": "environment"} STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_x_ode"}, - {"name": "y", "units": "dimensionless", "component": "my_y_ode"} + {"name": "y", "units": "dimensionless", "component": "my_y_ode"}, + {"name": "x", "units": "dimensionless", "component": "my_x_ode"} ] CONSTANT_INFO = [ @@ -47,8 +47,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, computed_constants, algebraic): - states[0] = -2.0 - states[1] = 0.0 + states[0] = 0.0 + states[1] = -2.0 constants[0] = 1.0 @@ -57,8 +57,8 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = states[1]*1.0 - rates[1] = (constants[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 + rates[1] = states[0]*1.0 + rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0 def compute_variables(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 94753f8e7..947c02d76 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -16,8 +16,8 @@ const size_t ALGEBRAIC_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component"}; const VariableInfo STATE_INFO[] = { - {"x", "dimensionless", "my_component"}, - {"y", "dimensionless", "my_component"} + {"y", "dimensionless", "my_component"}, + {"x", "dimensionless", "my_component"} }; const VariableInfo CONSTANT_INFO[] = { @@ -81,8 +81,8 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - states[0] = -2.0; - states[1] = 0.0; + states[0] = 0.0; + states[1] = -2.0; constants[0] = 1.0; } @@ -92,8 +92,8 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = states[1]*1.0; - rates[1] = (constants[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0; + rates[1] = states[0]*1.0; + rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index f24ba364b..40c2f4bf6 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -15,8 +15,8 @@ VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} STATE_INFO = [ - {"name": "x", "units": "dimensionless", "component": "my_component"}, - {"name": "y", "units": "dimensionless", "component": "my_component"} + {"name": "y", "units": "dimensionless", "component": "my_component"}, + {"name": "x", "units": "dimensionless", "component": "my_component"} ] CONSTANT_INFO = [ @@ -47,8 +47,8 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, computed_constants, algebraic): - states[0] = -2.0 - states[1] = 0.0 + states[0] = 0.0 + states[1] = -2.0 constants[0] = 1.0 @@ -57,8 +57,8 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = states[1]*1.0 - rates[1] = (constants[0]*(1.0-pow(states[0], 2.0))*states[1]-states[0])*1.0 + rates[1] = states[0]*1.0 + rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0 def compute_variables(voi, states, rates, constants, computed_constants, algebraic): diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 6c956cc25..86a1b80a0 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -16,13 +16,13 @@ const size_t ALGEBRAIC_COUNT = 2; const VariableInfo VOI_INFO = {"t", "dimensionless", "main"}; const VariableInfo STATE_INFO[] = { - {"y1", "dimensionless", "main"}, - {"y2", "dimensionless", "main"} + {"y2", "dimensionless", "main"}, + {"y1", "dimensionless", "main"} }; const VariableInfo CONSTANT_INFO[] = { - {"k1", "dimensionless", "main"}, {"k3", "dimensionless", "main"}, + {"k1", "dimensionless", "main"}, {"k2", "dimensionless", "main"} }; @@ -106,7 +106,7 @@ void objectiveFunction0(double *u, double *f, void *data) algebraic[0] = u[0]; - f[0] = 1.0-(states[0]+states[1]+algebraic[0]); + f[0] = 1.0-(states[1]+states[0]+algebraic[0]); } void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) @@ -123,10 +123,10 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - states[0] = 1.0; - states[1] = 0.0; - constants[0] = 0.04; - constants[1] = 1.0e4; + states[0] = 0.0; + states[1] = 1.0; + constants[0] = 1.0e4; + constants[1] = 0.04; constants[2] = 3.0e7; algebraic[0] = 0.0; } @@ -138,12 +138,12 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, constants, computedConstants, algebraic); - rates[0] = -constants[0]*states[0]+constants[1]*states[1]*algebraic[0]; - rates[1] = constants[0]*states[0]-constants[2]*pow(states[1], 2.0)-constants[1]*states[1]*algebraic[0]; + rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraic[0]; + rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraic[0]; } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { findRoot0(voi, states, rates, constants, computedConstants, algebraic); - algebraic[1] = 10000.0*states[1]; + algebraic[1] = 10000.0*states[0]; } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index f621da6df..c01e37e56 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -15,13 +15,13 @@ VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} STATE_INFO = [ - {"name": "y1", "units": "dimensionless", "component": "main"}, - {"name": "y2", "units": "dimensionless", "component": "main"} + {"name": "y2", "units": "dimensionless", "component": "main"}, + {"name": "y1", "units": "dimensionless", "component": "main"} ] CONSTANT_INFO = [ - {"name": "k1", "units": "dimensionless", "component": "main"}, {"name": "k3", "units": "dimensionless", "component": "main"}, + {"name": "k1", "units": "dimensionless", "component": "main"}, {"name": "k2", "units": "dimensionless", "component": "main"} ] @@ -63,7 +63,7 @@ def objective_function_0(u, f, data): algebraic[0] = u[0] - f[0] = 1.0-(states[0]+states[1]+algebraic[0]) + f[0] = 1.0-(states[1]+states[0]+algebraic[0]) def find_root_0(voi, states, rates, constants, computed_constants, algebraic): @@ -77,10 +77,10 @@ def find_root_0(voi, states, rates, constants, computed_constants, algebraic): def initialise_variables(states, rates, constants, computed_constants, algebraic): - states[0] = 1.0 - states[1] = 0.0 - constants[0] = 0.04 - constants[1] = 1.0e4 + states[0] = 0.0 + states[1] = 1.0 + constants[0] = 1.0e4 + constants[1] = 0.04 constants[2] = 3.0e7 algebraic[0] = 0.0 @@ -91,10 +91,10 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, constants, computed_constants, algebraic) - rates[0] = -constants[0]*states[0]+constants[1]*states[1]*algebraic[0] - rates[1] = constants[0]*states[0]-constants[2]*pow(states[1], 2.0)-constants[1]*states[1]*algebraic[0] + rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraic[0] + rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraic[0] def compute_variables(voi, states, rates, constants, computed_constants, algebraic): find_root_0(voi, states, rates, constants, computed_constants, algebraic) - algebraic[1] = 10000.0*states[1] + algebraic[1] = 10000.0*states[0] diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 8e0d686f7..04ef867e8 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -16,14 +16,14 @@ const size_t ALGEBRAIC_COUNT = 1; const VariableInfo VOI_INFO = {"t", "dimensionless", "main"}; const VariableInfo STATE_INFO[] = { - {"y1", "dimensionless", "main"}, {"y3", "dimensionless", "main"}, - {"y2", "dimensionless", "main"} + {"y2", "dimensionless", "main"}, + {"y1", "dimensionless", "main"} }; const VariableInfo CONSTANT_INFO[] = { - {"k1", "dimensionless", "main"}, {"k3", "dimensionless", "main"}, + {"k1", "dimensionless", "main"}, {"k2", "dimensionless", "main"} }; @@ -85,11 +85,11 @@ void deleteArray(double *array) void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - states[0] = 1.0; + states[0] = 0.0; states[1] = 0.0; - states[2] = 0.0; - constants[0] = 0.04; - constants[1] = 1.0e4; + states[2] = 1.0; + constants[0] = 1.0e4; + constants[1] = 0.04; constants[2] = 3.0e7; } @@ -99,12 +99,12 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - rates[0] = -constants[0]*states[0]+constants[1]*states[2]*states[1]; - rates[2] = constants[0]*states[0]-constants[2]*pow(states[2], 2.0)-constants[1]*states[2]*states[1]; - rates[1] = constants[2]*pow(states[2], 2.0); + rates[2] = -constants[1]*states[2]+constants[0]*states[1]*states[0]; + rates[1] = constants[1]*states[2]-constants[2]*pow(states[1], 2.0)-constants[0]*states[1]*states[0]; + rates[0] = constants[2]*pow(states[1], 2.0); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { - algebraic[0] = 10000.0*states[2]; + algebraic[0] = 10000.0*states[1]; } diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 0d47b31e4..ddfda730e 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -15,14 +15,14 @@ VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} STATE_INFO = [ - {"name": "y1", "units": "dimensionless", "component": "main"}, {"name": "y3", "units": "dimensionless", "component": "main"}, - {"name": "y2", "units": "dimensionless", "component": "main"} + {"name": "y2", "units": "dimensionless", "component": "main"}, + {"name": "y1", "units": "dimensionless", "component": "main"} ] CONSTANT_INFO = [ - {"name": "k1", "units": "dimensionless", "component": "main"}, {"name": "k3", "units": "dimensionless", "component": "main"}, + {"name": "k1", "units": "dimensionless", "component": "main"}, {"name": "k2", "units": "dimensionless", "component": "main"} ] @@ -51,11 +51,11 @@ def create_algebraic_array(): def initialise_variables(states, rates, constants, computed_constants, algebraic): - states[0] = 1.0 + states[0] = 0.0 states[1] = 0.0 - states[2] = 0.0 - constants[0] = 0.04 - constants[1] = 1.0e4 + states[2] = 1.0 + constants[0] = 1.0e4 + constants[1] = 0.04 constants[2] = 3.0e7 @@ -64,10 +64,10 @@ def compute_computed_constants(constants, computed_constants): def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - rates[0] = -constants[0]*states[0]+constants[1]*states[2]*states[1] - rates[2] = constants[0]*states[0]-constants[2]*pow(states[2], 2.0)-constants[1]*states[2]*states[1] - rates[1] = constants[2]*pow(states[2], 2.0) + rates[2] = -constants[1]*states[2]+constants[0]*states[1]*states[0] + rates[1] = constants[1]*states[2]-constants[2]*pow(states[1], 2.0)-constants[0]*states[1]*states[0] + rates[0] = constants[2]*pow(states[1], 2.0) def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = 10000.0*states[2] + algebraic[0] = 10000.0*states[1] diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index cc58f6fd4..ce2bd9222 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -14,14 +14,14 @@ const size_t ALGEBRAIC_COUNT = 1; const size_t EXTERNAL_COUNT = 1; const VariableInfo CONSTANT_INFO[] = { - {"E", "fmol", "SLC_template3_ss"}, - {"P_0", "per_fmol_sec4", "SLC_template3_ss"}, + {"P_5", "per_sec3", "SLC_template3_ss"}, {"q_Ao", "fmol", "SLC_template3_ss"}, - {"P_1", "per_fmol_sec4", "SLC_template3_ss"}, {"q_Ai", "fmol", "SLC_template3_ss"}, + {"P_4", "per_fmol2_sec3", "SLC_template3_ss"}, {"P_2", "per_fmol_sec3", "SLC_template3_ss"}, - {"P_5", "per_sec3", "SLC_template3_ss"}, - {"P_4", "per_fmol2_sec3", "SLC_template3_ss"} + {"P_1", "per_fmol_sec4", "SLC_template3_ss"}, + {"P_0", "per_fmol_sec4", "SLC_template3_ss"}, + {"E", "fmol", "SLC_template3_ss"} }; const VariableInfo COMPUTED_CONSTANT_INFO[] = { @@ -86,14 +86,14 @@ void deleteArray(double *array) void initialiseVariables(double *constants, double *computedConstants, double *algebraic) { - constants[0] = 1.1; - constants[1] = 21262500.0; - constants[2] = 150.0; - constants[3] = 3402000.0; - constants[4] = 2.0; - constants[5] = 2902500.0; - constants[6] = 810000.0; - constants[7] = 247140.0; + constants[0] = 810000.0; + constants[1] = 150.0; + constants[2] = 2.0; + constants[3] = 247140.0; + constants[4] = 2902500.0; + constants[5] = 3402000.0; + constants[6] = 21262500.0; + constants[7] = 1.1; } void computeComputedConstants(double *constants, double *computedConstants) @@ -103,5 +103,5 @@ void computeComputedConstants(double *constants, double *computedConstants) void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) { externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); - algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+externals[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]); + algebraic[0] = constants[7]*(constants[6]*constants[1]-constants[5]*constants[2])/(constants[4]*constants[2]+externals[0]*constants[1]+constants[3]*constants[2]*constants[1]+constants[0]); } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 78543cb69..07f234d0d 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -13,14 +13,14 @@ EXTERNAL_COUNT = 1 CONSTANT_INFO = [ - {"name": "E", "units": "fmol", "component": "SLC_template3_ss"}, - {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, + {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss"}, {"name": "q_Ao", "units": "fmol", "component": "SLC_template3_ss"}, - {"name": "P_1", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, {"name": "q_Ai", "units": "fmol", "component": "SLC_template3_ss"}, + {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss"}, {"name": "P_2", "units": "per_fmol_sec3", "component": "SLC_template3_ss"}, - {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss"}, - {"name": "P_4", "units": "per_fmol2_sec3", "component": "SLC_template3_ss"} + {"name": "P_1", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, + {"name": "P_0", "units": "per_fmol_sec4", "component": "SLC_template3_ss"}, + {"name": "E", "units": "fmol", "component": "SLC_template3_ss"} ] COMPUTED_CONSTANT_INFO = [ @@ -52,14 +52,14 @@ def create_externals_array(): def initialise_variables(constants, computed_constants, algebraic): - constants[0] = 1.1 - constants[1] = 21262500.0 - constants[2] = 150.0 - constants[3] = 3402000.0 - constants[4] = 2.0 - constants[5] = 2902500.0 - constants[6] = 810000.0 - constants[7] = 247140.0 + constants[0] = 810000.0 + constants[1] = 150.0 + constants[2] = 2.0 + constants[3] = 247140.0 + constants[4] = 2902500.0 + constants[5] = 3402000.0 + constants[6] = 21262500.0 + constants[7] = 1.1 def compute_computed_constants(constants, computed_constants): @@ -68,4 +68,4 @@ def compute_computed_constants(constants, computed_constants): def compute_variables(constants, computed_constants, algebraic, externals, external_variable): externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) - algebraic[0] = constants[0]*(constants[1]*constants[2]-constants[3]*constants[4])/(constants[5]*constants[4]+externals[0]*constants[2]+constants[7]*constants[4]*constants[2]+constants[6]) + algebraic[0] = constants[7]*(constants[6]*constants[1]-constants[5]*constants[2])/(constants[4]*constants[2]+externals[0]*constants[1]+constants[3]*constants[2]*constants[1]+constants[0]) From f76d0b19ddeda2b6c62d400c24329e36aa656290 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 4 Nov 2025 11:45:19 +1300 Subject: [PATCH 62/74] Renamed algebraic and external variables. --- src/analyser.cpp | 50 +- src/analyser_p.h | 4 +- src/analyserequation.cpp | 28 +- src/analyserequation_p.h | 4 +- src/analysermodel.cpp | 28 +- src/analysermodel_p.h | 4 +- src/analyservariable.cpp | 4 +- src/api/libcellml/analyserequation.h | 12 +- src/api/libcellml/analysermodel.h | 12 +- src/api/libcellml/analyservariable.h | 4 +- src/api/libcellml/generatorprofile.h | 160 +++--- src/api/libcellml/issue.h | 2 +- src/bindings/interface/analyserequation.i | 12 +- src/bindings/interface/analysermodel.i | 12 +- src/bindings/interface/generatorprofile.i | 108 ++-- src/bindings/interface/types.i | 2 +- src/bindings/javascript/analyserequation.cpp | 16 +- src/bindings/javascript/analysermodel.cpp | 12 +- src/bindings/javascript/analyservariable.cpp | 4 +- src/bindings/javascript/generatorprofile.cpp | 56 +-- src/bindings/javascript/issue.cpp | 2 +- src/bindings/python/__init__.py | 6 +- src/debug.cpp | 18 +- src/generator.cpp | 72 +-- src/generatorprofile.cpp | 374 +++++++------- src/generatorprofile_p.h | 28 +- src/generatorprofilesha1values.h | 4 +- src/generatorprofiletools.cpp | 28 +- src/issue.cpp | 2 +- src/utilities.cpp | 16 +- .../javascript/analyserequation.test.js | 16 +- .../bindings/javascript/analysermodel.test.js | 8 +- .../javascript/analyservariable.test.js | 8 +- .../javascript/generatorprofile.test.js | 84 ++-- tests/bindings/python/test_analyser.py | 26 +- .../bindings/python/test_generator_profile.py | 176 +++---- tests/bindings/python/test_issue.py | 2 +- tests/coverage/coverage.cpp | 78 +-- tests/generator/generatorprofile.cpp | 188 +++---- tests/resources/coverage/generator/model.c | 58 +-- tests/resources/coverage/generator/model.h | 16 +- .../generator/model.implementation.out | 54 +- .../coverage/generator/model.interface.out | 12 +- .../generator/model.modified.profile.c | 58 +-- .../generator/model.modified.profile.h | 16 +- .../generator/model.modified.profile.py | 50 +- tests/resources/coverage/generator/model.out | 30 +- tests/resources/coverage/generator/model.py | 50 +- .../algebraic_eqn_computed_var_on_rhs/model.c | 12 +- .../model.external.c | 24 +- .../model.external.h | 14 +- .../model.external.py | 20 +- .../algebraic_eqn_computed_var_on_rhs/model.h | 8 +- .../model.py | 10 +- .../algebraic_eqn_const_var_on_rhs/model.c | 12 +- .../algebraic_eqn_const_var_on_rhs/model.h | 8 +- .../algebraic_eqn_const_var_on_rhs/model.py | 10 +- .../algebraic_eqn_constant_on_rhs/model.c | 12 +- .../algebraic_eqn_constant_on_rhs/model.h | 8 +- .../algebraic_eqn_constant_on_rhs/model.py | 10 +- .../algebraic_eqn_derivative_on_rhs/model.c | 16 +- .../algebraic_eqn_derivative_on_rhs/model.h | 10 +- .../algebraic_eqn_derivative_on_rhs/model.py | 14 +- .../model.c | 16 +- .../model.h | 10 +- .../model.py | 14 +- .../algebraic_eqn_state_var_on_rhs/model.c | 16 +- .../algebraic_eqn_state_var_on_rhs/model.h | 10 +- .../algebraic_eqn_state_var_on_rhs/model.py | 14 +- .../model.c | 16 +- .../model.h | 10 +- .../model.py | 14 +- .../model.c | 32 +- .../model.external.c | 46 +- .../model.external.h | 14 +- .../model.external.py | 38 +- .../model.h | 8 +- .../model.py | 28 +- .../model.c | 52 +- .../model.external.c | 26 +- .../model.external.h | 14 +- .../model.external.py | 22 +- .../model.h | 8 +- .../model.py | 48 +- .../model.not.ordered.c | 44 +- .../model.not.ordered.h | 8 +- .../model.not.ordered.py | 40 +- .../model.ordered.c | 44 +- .../model.ordered.h | 8 +- .../model.ordered.py | 40 +- .../algebraic_unknown_var_on_rhs/model.c | 12 +- .../algebraic_unknown_var_on_rhs/model.h | 8 +- .../algebraic_unknown_var_on_rhs/model.py | 10 +- .../generator/cell_geometry_model/model.c | 12 +- .../cell_geometry_model/model.external.c | 28 +- .../cell_geometry_model/model.external.h | 14 +- .../cell_geometry_model/model.external.py | 24 +- .../generator/cell_geometry_model/model.h | 8 +- .../generator/cell_geometry_model/model.py | 10 +- .../model.c | 18 +- .../model.h | 10 +- .../model.py | 16 +- .../generator/cellml_slc_example/model.py | 10 +- .../model.c | 14 +- .../model.h | 10 +- .../model.py | 12 +- .../cellml_unit_scaling_constant/model.c | 12 +- .../cellml_unit_scaling_constant/model.h | 8 +- .../cellml_unit_scaling_constant/model.py | 10 +- .../cellml_unit_scaling_rate/model.c | 18 +- .../cellml_unit_scaling_rate/model.h | 10 +- .../cellml_unit_scaling_rate/model.py | 16 +- .../cellml_unit_scaling_state/model.c | 18 +- .../cellml_unit_scaling_state/model.h | 10 +- .../cellml_unit_scaling_state/model.py | 16 +- .../model.c | 14 +- .../model.h | 10 +- .../model.py | 12 +- .../model.c | 14 +- .../model.h | 10 +- .../model.py | 12 +- .../cellml_unit_scaling_voi_direct/model.c | 14 +- .../cellml_unit_scaling_voi_direct/model.h | 10 +- .../cellml_unit_scaling_voi_direct/model.py | 12 +- .../cellml_unit_scaling_voi_indirect/model.c | 14 +- .../cellml_unit_scaling_voi_indirect/model.h | 10 +- .../cellml_unit_scaling_voi_indirect/model.py | 12 +- .../generator/dae_cellml_1_1_model/model.c | 72 +-- .../generator/dae_cellml_1_1_model/model.h | 10 +- .../generator/dae_cellml_1_1_model/model.py | 68 +-- .../generator/dependent_eqns/model.c | 18 +- .../generator/dependent_eqns/model.h | 10 +- .../generator/dependent_eqns/model.py | 16 +- .../model.c | 472 ++++++++--------- .../model.h | 10 +- .../model.py | 474 +++++++++--------- .../model.c | 252 +++++----- .../model.h | 10 +- .../model.py | 250 ++++----- .../model.algebraic.c | 70 +-- .../model.algebraic.h | 16 +- .../model.algebraic.py | 70 +-- .../model.c | 60 +-- .../model.computed.constant.c | 72 +-- .../model.computed.constant.h | 16 +- .../model.computed.constant.py | 72 +-- .../model.constant.c | 72 +-- .../model.constant.h | 16 +- .../model.constant.py | 72 +-- .../model.dae.c | 332 ++++++------ .../model.dae.external.c | 292 +++++------ .../model.dae.external.h | 16 +- .../model.dae.external.py | 288 +++++------ .../model.dae.h | 10 +- .../model.dae.py | 324 ++++++------ .../model.dependent.algebraic.c | 70 +-- .../model.dependent.algebraic.h | 16 +- .../model.dependent.algebraic.py | 70 +-- .../model.dependent.computed.constant.c | 84 ++-- .../model.dependent.computed.constant.h | 16 +- .../model.dependent.computed.constant.py | 84 ++-- .../model.dependent.constant.c | 76 +-- .../model.dependent.constant.h | 16 +- .../model.dependent.constant.py | 76 +-- .../model.dependent.state.c | 52 +- .../model.dependent.state.h | 16 +- .../model.dependent.state.py | 52 +- .../model.external.c | 54 +- .../model.external.h | 16 +- .../model.external.py | 54 +- .../model.h | 10 +- .../model.py | 62 +-- .../model.state.c | 66 +-- .../model.state.h | 16 +- .../model.state.py | 66 +-- .../generator/noble_model_1962/model.c | 70 +-- .../generator/noble_model_1962/model.h | 10 +- .../generator/noble_model_1962/model.py | 72 +-- .../generator/ode_computed_var_on_rhs/model.c | 14 +- .../generator/ode_computed_var_on_rhs/model.h | 10 +- .../ode_computed_var_on_rhs/model.py | 12 +- .../model.c | 14 +- .../model.h | 10 +- .../model.py | 12 +- .../generator/ode_const_var_on_rhs/model.c | 14 +- .../generator/ode_const_var_on_rhs/model.h | 10 +- .../generator/ode_const_var_on_rhs/model.py | 12 +- .../model.c | 14 +- .../model.h | 10 +- .../model.py | 12 +- .../generator/ode_constant_on_rhs/model.c | 14 +- .../generator/ode_constant_on_rhs/model.h | 10 +- .../generator/ode_constant_on_rhs/model.py | 12 +- .../ode_constant_on_rhs_one_component/model.c | 14 +- .../ode_constant_on_rhs_one_component/model.h | 10 +- .../model.py | 12 +- .../ode_multiple_dependent_odes/model.c | 14 +- .../ode_multiple_dependent_odes/model.h | 10 +- .../ode_multiple_dependent_odes/model.py | 12 +- .../model.c | 14 +- .../model.h | 10 +- .../model.py | 12 +- .../ode_multiple_odes_with_same_name/model.c | 14 +- .../ode_multiple_odes_with_same_name/model.h | 10 +- .../ode_multiple_odes_with_same_name/model.py | 12 +- .../generator/ode_unknown_var_on_rhs/model.c | 14 +- .../generator/ode_unknown_var_on_rhs/model.h | 10 +- .../generator/ode_unknown_var_on_rhs/model.py | 12 +- .../robertson_model_1966/model.dae.c | 42 +- .../robertson_model_1966/model.dae.h | 10 +- .../robertson_model_1966/model.dae.py | 38 +- .../robertson_model_1966/model.ode.c | 16 +- .../robertson_model_1966/model.ode.h | 10 +- .../robertson_model_1966/model.ode.py | 14 +- .../generator/sine_model_imports/model.c | 20 +- .../generator/sine_model_imports/model.h | 10 +- .../generator/sine_model_imports/model.py | 18 +- .../model.c | 24 +- .../model.h | 14 +- .../model.py | 20 +- .../model.c | 14 +- .../model.h | 10 +- .../model.py | 12 +- 223 files changed, 4268 insertions(+), 4268 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index be35fa881..cd9728a74 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -238,13 +238,13 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, bool checkNl for (const auto &variable : mAllVariables) { switch (variable->mType) { case AnalyserInternalVariable::Type::INITIALISED: - case AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC: + case AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC_VARIABLE: // The equation contains an initialised variable, so track it // and consider it as an algebraic variable. initialisedVariables.push_back(variable); - variable->mType = AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC; + variable->mType = AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC_VARIABLE; break; default: @@ -302,15 +302,15 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &model, bool checkNl AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT : mComputedVariableBasedConstant ? AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT : - AnalyserInternalVariable::Type::ALGEBRAIC; + AnalyserInternalVariable::Type::ALGEBRAIC_VARIABLE; } switch (variable->mType) { case AnalyserInternalVariable::Type::STATE: case AnalyserInternalVariable::Type::COMPUTED_TRUE_CONSTANT: case AnalyserInternalVariable::Type::COMPUTED_VARIABLE_BASED_CONSTANT: - case AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC: - case AnalyserInternalVariable::Type::ALGEBRAIC: + case AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC_VARIABLE: + case AnalyserInternalVariable::Type::ALGEBRAIC_VARIABLE: variable->mIsKnownStateVariable = variable->mType == AnalyserInternalVariable::Type::STATE; mUnknownVariables.push_back(variable); @@ -2730,7 +2730,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // an initial guess) that needs to be computed using an NLA // system. So, requalify the unknown variable and equation. - unknownVariable->mType = AnalyserInternalVariable::Type::ALGEBRAIC; + unknownVariable->mType = AnalyserInternalVariable::Type::ALGEBRAIC_VARIABLE; internalEquation->mType = AnalyserInternalEquation::Type::ALGEBRAIC; break; @@ -2887,8 +2887,8 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) auto stateIndex = MAX_SIZE_T; auto constantIndex = MAX_SIZE_T; auto computedConstantIndex = MAX_SIZE_T; - auto algebraicIndex = MAX_SIZE_T; - auto externalIndex = MAX_SIZE_T; + auto algebraicVariableIndex = MAX_SIZE_T; + auto externalVariableIndex = MAX_SIZE_T; for (const auto &internalVariable : mInternalVariables) { // Determine the type of the variable. @@ -2896,7 +2896,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) AnalyserVariable::Type variableType; if (internalVariable->mIsExternalVariable) { - variableType = AnalyserVariable::Type::EXTERNAL; + variableType = AnalyserVariable::Type::EXTERNAL_VARIABLE; } else { switch (internalVariable->mType) { case AnalyserInternalVariable::Type::STATE: @@ -2912,9 +2912,9 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) variableType = AnalyserVariable::Type::COMPUTED_CONSTANT; break; - case AnalyserInternalVariable::Type::ALGEBRAIC: - case AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC: - variableType = AnalyserVariable::Type::ALGEBRAIC; + case AnalyserInternalVariable::Type::ALGEBRAIC_VARIABLE: + case AnalyserInternalVariable::Type::INITIALISED_ALGEBRAIC_VARIABLE: + variableType = AnalyserVariable::Type::ALGEBRAIC_VARIABLE; break; default: // AnalyserInternalVariable::Type::VARIABLE_OF_INTEGRATION. @@ -2943,7 +2943,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Correct the type of the variable if it is a computed constant that is computed using an NLA equation. if ((variableType == AnalyserVariable::Type::COMPUTED_CONSTANT) && isNlaEquation) { - variableType = AnalyserVariable::Type::ALGEBRAIC; + variableType = AnalyserVariable::Type::ALGEBRAIC_VARIABLE; } // Populate and keep track of the state/variable. @@ -2957,10 +2957,10 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) ++constantIndex : (variableType == AnalyserVariable::Type::COMPUTED_CONSTANT) ? ++computedConstantIndex : - (variableType == AnalyserVariable::Type::ALGEBRAIC) ? - ++algebraicIndex : - ++externalIndex, - (variableType == AnalyserVariable::Type::EXTERNAL) ? + (variableType == AnalyserVariable::Type::ALGEBRAIC_VARIABLE) ? + ++algebraicVariableIndex : + ++externalVariableIndex, + (variableType == AnalyserVariable::Type::EXTERNAL_VARIABLE) ? nullptr : internalVariable->mInitialisingVariable, internalVariable->mVariable, @@ -2975,10 +2975,10 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) mModel->mPimpl->mConstants.push_back(variable); } else if (variableType == AnalyserVariable::Type::COMPUTED_CONSTANT) { mModel->mPimpl->mComputedConstants.push_back(variable); - } else if (variableType == AnalyserVariable::Type::ALGEBRAIC) { - mModel->mPimpl->mAlgebraic.push_back(variable); - } else { // AnalyserVariable::Type::EXTERNAL. - mModel->mPimpl->mExternals.push_back(variable); + } else if (variableType == AnalyserVariable::Type::ALGEBRAIC_VARIABLE) { + mModel->mPimpl->mAlgebraicVariables.push_back(variable); + } else { // AnalyserVariable::Type::EXTERNAL_VARIABLE. + mModel->mPimpl->mExternalVariables.push_back(variable); } } @@ -3086,10 +3086,10 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) equation->mPimpl->mStates.push_back(variable); } else if (variableType == AnalyserVariable::Type::COMPUTED_CONSTANT) { equation->mPimpl->mComputedConstants.push_back(variable); - } else if (variableType == AnalyserVariable::Type::ALGEBRAIC) { - equation->mPimpl->mAlgebraic.push_back(variable); - } else { // AnalyserVariable::Type::EXTERNAL. - equation->mPimpl->mExternals.push_back(variable); + } else if (variableType == AnalyserVariable::Type::ALGEBRAIC_VARIABLE) { + equation->mPimpl->mAlgebraicVariables.push_back(variable); + } else { // AnalyserVariable::Type::EXTERNAL_VARIABLE. + equation->mPimpl->mExternalVariables.push_back(variable); } } diff --git a/src/analyser_p.h b/src/analyser_p.h index 97779631a..254a2ef4c 100644 --- a/src/analyser_p.h +++ b/src/analyser_p.h @@ -51,8 +51,8 @@ struct AnalyserInternalVariable CONSTANT, COMPUTED_TRUE_CONSTANT, COMPUTED_VARIABLE_BASED_CONSTANT, - INITIALISED_ALGEBRAIC, - ALGEBRAIC, + INITIALISED_ALGEBRAIC_VARIABLE, + ALGEBRAIC_VARIABLE, OVERCONSTRAINED }; diff --git a/src/analyserequation.cpp b/src/analyserequation.cpp index c559bfe64..fff98bb0f 100644 --- a/src/analyserequation.cpp +++ b/src/analyserequation.cpp @@ -176,42 +176,42 @@ AnalyserVariablePtr AnalyserEquation::computedConstant(size_t index) const return mPimpl->mComputedConstants[index]; } -size_t AnalyserEquation::algebraicCount() const +size_t AnalyserEquation::algebraicVariableCount() const { - return mPimpl->mAlgebraic.size(); + return mPimpl->mAlgebraicVariables.size(); } -std::vector AnalyserEquation::algebraic() const +std::vector AnalyserEquation::algebraicVariables() const { - return mPimpl->mAlgebraic; + return mPimpl->mAlgebraicVariables; } -AnalyserVariablePtr AnalyserEquation::algebraic(size_t index) const +AnalyserVariablePtr AnalyserEquation::algebraicVariable(size_t index) const { - if (index >= mPimpl->mAlgebraic.size()) { + if (index >= mPimpl->mAlgebraicVariables.size()) { return {}; } - return mPimpl->mAlgebraic[index]; + return mPimpl->mAlgebraicVariables[index]; } -size_t AnalyserEquation::externalCount() const +size_t AnalyserEquation::externalVariableCount() const { - return mPimpl->mExternals.size(); + return mPimpl->mExternalVariables.size(); } -std::vector AnalyserEquation::externals() const +std::vector AnalyserEquation::externalVariables() const { - return mPimpl->mExternals; + return mPimpl->mExternalVariables; } -AnalyserVariablePtr AnalyserEquation::external(size_t index) const +AnalyserVariablePtr AnalyserEquation::externalVariable(size_t index) const { - if (index >= mPimpl->mExternals.size()) { + if (index >= mPimpl->mExternalVariables.size()) { return {}; } - return mPimpl->mExternals[index]; + return mPimpl->mExternalVariables[index]; } } // namespace libcellml diff --git a/src/analyserequation_p.h b/src/analyserequation_p.h index a75f6faff..a896c0c87 100644 --- a/src/analyserequation_p.h +++ b/src/analyserequation_p.h @@ -36,8 +36,8 @@ struct AnalyserEquation::AnalyserEquationImpl std::vector mStates; std::vector mComputedConstants; - std::vector mAlgebraic; - std::vector mExternals; + std::vector mAlgebraicVariables; + std::vector mExternalVariables; std::vector mDependencies; std::vector mNlaSiblings; diff --git a/src/analysermodel.cpp b/src/analysermodel.cpp index 9b783f164..2502aa93e 100644 --- a/src/analysermodel.cpp +++ b/src/analysermodel.cpp @@ -175,58 +175,58 @@ AnalyserVariablePtr AnalyserModel::computedConstant(size_t index) const return mPimpl->mComputedConstants[index]; } -size_t AnalyserModel::algebraicCount() const +size_t AnalyserModel::algebraicVariableCount() const { if (!isValid()) { return 0; } - return mPimpl->mAlgebraic.size(); + return mPimpl->mAlgebraicVariables.size(); } -std::vector AnalyserModel::algebraic() const +std::vector AnalyserModel::algebraicVariables() const { if (!isValid()) { return {}; } - return mPimpl->mAlgebraic; + return mPimpl->mAlgebraicVariables; } -AnalyserVariablePtr AnalyserModel::algebraic(size_t index) const +AnalyserVariablePtr AnalyserModel::algebraicVariable(size_t index) const { - if (!isValid() || (index >= mPimpl->mAlgebraic.size())) { + if (!isValid() || (index >= mPimpl->mAlgebraicVariables.size())) { return {}; } - return mPimpl->mAlgebraic[index]; + return mPimpl->mAlgebraicVariables[index]; } -size_t AnalyserModel::externalCount() const +size_t AnalyserModel::externalVariableCount() const { if (!isValid()) { return 0; } - return mPimpl->mExternals.size(); + return mPimpl->mExternalVariables.size(); } -std::vector AnalyserModel::externals() const +std::vector AnalyserModel::externalVariables() const { if (!isValid()) { return {}; } - return mPimpl->mExternals; + return mPimpl->mExternalVariables; } -AnalyserVariablePtr AnalyserModel::external(size_t index) const +AnalyserVariablePtr AnalyserModel::externalVariable(size_t index) const { - if (!isValid() || (index >= mPimpl->mExternals.size())) { + if (!isValid() || (index >= mPimpl->mExternalVariables.size())) { return {}; } - return mPimpl->mExternals[index]; + return mPimpl->mExternalVariables[index]; } size_t AnalyserModel::equationCount() const diff --git a/src/analysermodel_p.h b/src/analysermodel_p.h index 24cb80e58..3d5606a89 100644 --- a/src/analysermodel_p.h +++ b/src/analysermodel_p.h @@ -38,8 +38,8 @@ struct AnalyserModel::AnalyserModelImpl std::vector mStates; std::vector mConstants; std::vector mComputedConstants; - std::vector mAlgebraic; - std::vector mExternals; + std::vector mAlgebraicVariables; + std::vector mExternalVariables; std::vector mEquations; diff --git a/src/analyservariable.cpp b/src/analyservariable.cpp index 3c03d8473..a61417df7 100644 --- a/src/analyservariable.cpp +++ b/src/analyservariable.cpp @@ -65,8 +65,8 @@ static const std::map typeToString = { {AnalyserVariable::Type::STATE, "state"}, {AnalyserVariable::Type::CONSTANT, "constant"}, {AnalyserVariable::Type::COMPUTED_CONSTANT, "computed_constant"}, - {AnalyserVariable::Type::ALGEBRAIC, "algebraic"}, - {AnalyserVariable::Type::EXTERNAL, "external"}}; + {AnalyserVariable::Type::ALGEBRAIC_VARIABLE, "algebraic_variable"}, + {AnalyserVariable::Type::EXTERNAL_VARIABLE, "external_variable"}}; std::string AnalyserVariable::typeAsString(Type type) { diff --git a/src/api/libcellml/analyserequation.h b/src/api/libcellml/analyserequation.h index 2e5f601b1..75782ad70 100644 --- a/src/api/libcellml/analyserequation.h +++ b/src/api/libcellml/analyserequation.h @@ -230,7 +230,7 @@ class LIBCELLML_EXPORT AnalyserEquation * * @return The number of algebraic variables. */ - size_t algebraicCount() const; + size_t algebraicVariableCount() const; /** * @brief Get the algebraic variables computed by this @ref AnalyserEquation. @@ -239,7 +239,7 @@ class LIBCELLML_EXPORT AnalyserEquation * * @return The algebraic variables as a @c std::vector. */ - std::vector algebraic() const; + std::vector algebraicVariables() const; /** * @brief Get the algebraic variable, at @p index, computed by this @ref AnalyserEquation. @@ -250,7 +250,7 @@ class LIBCELLML_EXPORT AnalyserEquation * * @return The algebraic variable, at @p index, on success, @c nullptr on failure. */ - AnalyserVariablePtr algebraic(size_t index) const; + AnalyserVariablePtr algebraicVariable(size_t index) const; /** * @brief Get the number of external variables computed by this @ref AnalyserEquation. @@ -259,7 +259,7 @@ class LIBCELLML_EXPORT AnalyserEquation * * @return The number of external variables. */ - size_t externalCount() const; + size_t externalVariableCount() const; /** * @brief Get the external variables computed by this @ref AnalyserEquation. @@ -268,7 +268,7 @@ class LIBCELLML_EXPORT AnalyserEquation * * @return The external variables as a @c std::vector. */ - std::vector externals() const; + std::vector externalVariables() const; /** * @brief Get the external variable, at @p index, computed by this @ref AnalyserEquation. @@ -279,7 +279,7 @@ class LIBCELLML_EXPORT AnalyserEquation * * @return The external variable, at @p index, on success, @c nullptr on failure. */ - AnalyserVariablePtr external(size_t index) const; + AnalyserVariablePtr externalVariable(size_t index) const; private: AnalyserEquation(); /**< Constructor, @private. */ diff --git a/src/api/libcellml/analysermodel.h b/src/api/libcellml/analysermodel.h index f5d745d15..7d4195735 100644 --- a/src/api/libcellml/analysermodel.h +++ b/src/api/libcellml/analysermodel.h @@ -208,7 +208,7 @@ class LIBCELLML_EXPORT AnalyserModel * * @return The number of algebraic variables. */ - size_t algebraicCount() const; + size_t algebraicVariableCount() const; /** * @brief Get the algebraic variables. @@ -217,7 +217,7 @@ class LIBCELLML_EXPORT AnalyserModel * * @return The algebraic variables as a @c std::vector. */ - std::vector algebraic() const; + std::vector algebraicVariables() const; /** * @brief Get the algebraic variable at @p index. @@ -229,7 +229,7 @@ class LIBCELLML_EXPORT AnalyserModel * @return The algebraic variable at the given @p index on success, @c nullptr on * failure. */ - AnalyserVariablePtr algebraic(size_t index) const; + AnalyserVariablePtr algebraicVariable(size_t index) const; /** * @brief Get the number of external variables. @@ -238,7 +238,7 @@ class LIBCELLML_EXPORT AnalyserModel * * @return The number of external variables. */ - size_t externalCount() const; + size_t externalVariableCount() const; /** * @brief Get the external variables. @@ -247,7 +247,7 @@ class LIBCELLML_EXPORT AnalyserModel * * @return The external variables as a @c std::vector. */ - std::vector externals() const; + std::vector externalVariables() const; /** * @brief Get the external variable at @p index. @@ -259,7 +259,7 @@ class LIBCELLML_EXPORT AnalyserModel * @return The external variable at the given @p index on success, @c nullptr on * failure. */ - AnalyserVariablePtr external(size_t index) const; + AnalyserVariablePtr externalVariable(size_t index) const; /** * @brief Get the number of equations. diff --git a/src/api/libcellml/analyservariable.h b/src/api/libcellml/analyservariable.h index 24d8566d6..7adcc5c1c 100644 --- a/src/api/libcellml/analyservariable.h +++ b/src/api/libcellml/analyservariable.h @@ -44,8 +44,8 @@ class LIBCELLML_EXPORT AnalyserVariable STATE, /**< The variable is a state. */ CONSTANT, /**< The variable is a constant (e.g. x = 3). */ COMPUTED_CONSTANT, /**< The variable is a computed constant (e.g. x = 3+5, x = 3+z, x = y+z where y and z are constants). */ - ALGEBRAIC, /**< The variable is an algebraic variable. */ - EXTERNAL /**< The variable is an external variable, i.e. not computed as part of the model. */ + ALGEBRAIC_VARIABLE, /**< The variable is an algebraic variable. */ + EXTERNAL_VARIABLE /**< The variable is an external variable, i.e. not computed as part of the model. */ }; ~AnalyserVariable(); /**< Destructor, @private. */ diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index 8608cc8d8..13bbc64b4 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -2558,100 +2558,100 @@ class LIBCELLML_EXPORT GeneratorProfile void setImplementationComputedConstantCountString(const std::string &implementationComputedConstantCountString); /** - * @brief Get the @c std::string for the interface of the algebraic count + * @brief Get the @c std::string for the interface of the algebraic variable count * constant. * - * Return the @c std::string for the interface of the algebraic count + * Return the @c std::string for the interface of the algebraic variable count * constant. * - * @return The @c std::string for the interface of the algebraic count + * @return The @c std::string for the interface of the algebraic variable count * constant. */ - std::string interfaceAlgebraicCountString() const; + std::string interfaceAlgebraicVariableCountString() const; /** - * @brief Set the @c std::string for the interface of the algebraic count + * @brief Set the @c std::string for the interface of the algebraic variable count * constant. * - * Set the @c std::string for the interface of the algebraic count constant. + * Set the @c std::string for the interface of the algebraic variable count constant. * - * @param interfaceAlgebraicCountString The @c std::string to use for the - * interface of the algebraic count constant. + * @param interfaceAlgebraicVariableCountString The @c std::string to use for the + * interface of the algebraic variable count constant. */ - void setInterfaceAlgebraicCountString(const std::string &interfaceAlgebraicCountString); + void setInterfaceAlgebraicVariableCountString(const std::string &interfaceAlgebraicVariableCountString); /** * @brief Get the @c std::string for the implementation of the algebraic - * count constant. + * variable count constant. * - * Return the @c std::string for the implementation of the algebraic count + * Return the @c std::string for the implementation of the algebraic variable count * constant. * - * @return The @c std::string for the implementation of the algebraic count + * @return The @c std::string for the implementation of the algebraic variable count * constant. */ - std::string implementationAlgebraicCountString() const; + std::string implementationAlgebraicVariableCountString() const; /** * @brief Set the @c std::string for the implementation of the algebraic - * count constant. + * variable count constant. * - * Set the @c std::string for the implementation of the algebraic count - * constant. To be useful, the string should contain the [ALGEBRAIC_COUNT] + * Set the @c std::string for the implementation of the algebraic variable count + * constant. To be useful, the string should contain the [ALGEBRAIC_VARIABLE_COUNT] * tag, which will be replaced with the number of states in the model. * - * @param implementationAlgebraicCountString The @c std::string to use for - * the implementation of the algebraic count constant. + * @param implementationAlgebraicVariableCountString The @c std::string to use for + * the implementation of the algebraic variable count constant. */ - void setImplementationAlgebraicCountString(const std::string &implementationAlgebraicCountString); + void setImplementationAlgebraicVariableCountString(const std::string &implementationAlgebraicVariableCountString); /** - * @brief Get the @c std::string for the interface of the external count + * @brief Get the @c std::string for the interface of the external variable count * constant. * - * Return the @c std::string for the interface of the external count + * Return the @c std::string for the interface of the external variable count * constant. * - * @return The @c std::string for the interface of the external count + * @return The @c std::string for the interface of the external variable count * constant. */ - std::string interfaceExternalCountString() const; + std::string interfaceExternalVariableCountString() const; /** - * @brief Set the @c std::string for the interface of the external count + * @brief Set the @c std::string for the interface of the external variable count * constant. * - * Set the @c std::string for the interface of the external count constant. + * Set the @c std::string for the interface of the external variable count constant. * - * @param interfaceExternalCountString The @c std::string to use for the - * interface of the external count constant. + * @param interfaceExternalVariableCountString The @c std::string to use for the + * interface of the external variable count constant. */ - void setInterfaceExternalCountString(const std::string &interfaceExternalCountString); + void setInterfaceExternalVariableCountString(const std::string &interfaceExternalVariableCountString); /** * @brief Get the @c std::string for the implementation of the external - * count constant. + * variable count constant. * - * Return the @c std::string for the implementation of the external count + * Return the @c std::string for the implementation of the external variable count * constant. * - * @return The @c std::string for the implementation of the external count + * @return The @c std::string for the implementation of the external variable count * constant. */ - std::string implementationExternalCountString() const; + std::string implementationExternalVariableCountString() const; /** * @brief Set the @c std::string for the implementation of the external - * count constant. + * variable count constant. * - * Set the @c std::string for the implementation of the external count - * constant. To be useful, the string should contain the [EXTERNAL_COUNT] + * Set the @c std::string for the implementation of the external variable count + * constant. To be useful, the string should contain the [EXTERNAL_VARIABLE_COUNT] * tag, which will be replaced with the number of states in the model. * - * @param implementationExternalCountString The @c std::string to use for - * the implementation of the external count constant. + * @param implementationExternalVariableCountString The @c std::string to use for + * the implementation of the external variable count constant. */ - void setImplementationExternalCountString(const std::string &implementationExternalCountString); + void setImplementationExternalVariableCountString(const std::string &implementationExternalVariableCountString); /** * @brief Get the @c std::string for the data structure for the variable @@ -2890,7 +2890,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of some information about * the different algebraic variables. */ - std::string interfaceAlgebraicInfoString() const; + std::string interfaceAlgebraicVariableInfoString() const; /** * @brief Set the @c std::string for the interface of some information about @@ -2899,10 +2899,10 @@ class LIBCELLML_EXPORT GeneratorProfile * Set the @c std::string for the interface of some information about the * different algebraic variables. * - * @param interfaceAlgebraicInfoString The @c std::string to use for the + * @param interfaceAlgebraicVariableInfoString The @c std::string to use for the * interface of some information about the different algebraic variables. */ - void setInterfaceAlgebraicInfoString(const std::string &interfaceAlgebraicInfoString); + void setInterfaceAlgebraicVariableInfoString(const std::string &interfaceAlgebraicVariableInfoString); /** * @brief Get the @c std::string for the implementation of some information @@ -2914,7 +2914,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of some information * about the different algebraic variables. */ - std::string implementationAlgebraicInfoString() const; + std::string implementationAlgebraicVariableInfoString() const; /** * @brief Set the @c std::string for the implementation of some information @@ -2925,10 +2925,10 @@ class LIBCELLML_EXPORT GeneratorProfile * tag, which will be replaced with some information about the different * algebraic variables. * - * @param implementationAlgebraicInfoString The @c std::string to use for the + * @param implementationAlgebraicVariableInfoString The @c std::string to use for the * implementation of some information about the different algebraic variables. */ - void setImplementationAlgebraicInfoString(const std::string &implementationAlgebraicInfoString); + void setImplementationAlgebraicVariableInfoString(const std::string &implementationAlgebraicVariableInfoString); /** * @brief Get the @c std::string for the interface of some information about @@ -2940,7 +2940,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the interface of some information about * the different external variables. */ - std::string interfaceExternalInfoString() const; + std::string interfaceExternalVariableInfoString() const; /** * @brief Set the @c std::string for the interface of some information about @@ -2949,10 +2949,10 @@ class LIBCELLML_EXPORT GeneratorProfile * Set the @c std::string for the interface of some information about the * different external variables. * - * @param interfaceExternalInfoString The @c std::string to use for the + * @param interfaceExternalVariableInfoString The @c std::string to use for the * interface of some information about the different external variables. */ - void setInterfaceExternalInfoString(const std::string &interfaceExternalInfoString); + void setInterfaceExternalVariableInfoString(const std::string &interfaceExternalVariableInfoString); /** * @brief Get the @c std::string for the implementation of some information @@ -2964,7 +2964,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation of some information * about the different external variables. */ - std::string implementationExternalInfoString() const; + std::string implementationExternalVariableInfoString() const; /** * @brief Set the @c std::string for the implementation of some information @@ -2975,10 +2975,10 @@ class LIBCELLML_EXPORT GeneratorProfile * tag, which will be replaced with some information about the different * external variables. * - * @param implementationExternalInfoString The @c std::string to use for the + * @param implementationExternalVariableInfoString The @c std::string to use for the * implementation of some information about the different external variables. */ - void setImplementationExternalInfoString(const std::string &implementationExternalInfoString); + void setImplementationExternalVariableInfoString(const std::string &implementationExternalVariableInfoString); /** * @brief Get the @c std::string for an entry in an array for some @@ -3104,42 +3104,42 @@ class LIBCELLML_EXPORT GeneratorProfile void setComputedConstantsArrayString(const std::string &computedConstantsArrayString); /** - * @brief Get the @c std::string for the name of the algebraic array. + * @brief Get the @c std::string for the name of the algebraic variables array. * - * Return the @c std::string for the name of the algebraic array. + * Return the @c std::string for the name of the algebraic variables array. * - * @return The @c std::string for the name of the algebraic array. + * @return The @c std::string for the name of the algebraic variables array. */ - std::string algebraicArrayString() const; + std::string algebraicVariablesArrayString() const; /** - * @brief Set the @c std::string for the name of the algebraic array. + * @brief Set the @c std::string for the name of the algebraic variables array. * - * Set the @c std::string for the name of the algebraic array. + * Set the @c std::string for the name of the algebraic variables array. * - * @param algebraicArrayString The @c std::string to use for the name of the - * algebraic array. + * @param algebraicVariablesArrayString The @c std::string to use for the name of the + * algebraic variables array. */ - void setAlgebraicArrayString(const std::string &algebraicArrayString); + void setAlgebraicVariablesArrayString(const std::string &algebraicVariablesArrayString); /** - * @brief Get the @c std::string for the name of the external array. + * @brief Get the @c std::string for the name of the external variables array. * - * Return the @c std::string for the name of the external array. + * Return the @c std::string for the name of the external variables array. * - * @return The @c std::string for the name of the external array. + * @return The @c std::string for the name of the external variables array. */ - std::string externalArrayString() const; + std::string externalVariablesArrayString() const; /** - * @brief Set the @c std::string for the name of the external array. + * @brief Set the @c std::string for the name of the external variables array. * - * Set the @c std::string for the name of the external array. + * Set the @c std::string for the name of the external variables array. * - * @param externalArrayString The @c std::string to use for the name of the - * external array. + * @param externalVariablesArrayString The @c std::string to use for the name of the + * external variables array. */ - void setExternalArrayString(const std::string &externalArrayString); + void setExternalVariablesArrayString(const std::string &externalVariablesArrayString); /** * @brief Get the @c std::string for the type definition of an external @@ -3591,7 +3591,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to create the algebraic variables array. */ - std::string interfaceCreateAlgebraicArrayMethodString() const; + std::string interfaceCreateAlgebraicVariablesArrayMethodString() const; /** * @brief Set the @c std::string for the interface to create the algebraic variables @@ -3599,10 +3599,10 @@ class LIBCELLML_EXPORT GeneratorProfile * * Set the @c std::string for the interface to create the algebraic variables array. * - * @param interfaceCreateAlgebraicArrayMethodString The @c std::string to use + * @param interfaceCreateAlgebraicVariablesArrayMethodString The @c std::string to use * for the interface to create the algebraic variables array. */ - void setInterfaceCreateAlgebraicArrayMethodString(const std::string &interfaceCreateAlgebraicArrayMethodString); + void setInterfaceCreateAlgebraicVariablesArrayMethodString(const std::string &interfaceCreateAlgebraicVariablesArrayMethodString); /** * @brief Get the @c std::string for the implementation to create the algebraic variables @@ -3614,7 +3614,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation to create the algebraic variables * array. */ - std::string implementationCreateAlgebraicArrayMethodString() const; + std::string implementationCreateAlgebraicVariablesArrayMethodString() const; /** * @brief Set the @c std::string for the implementation to create the algebraic variables @@ -3622,10 +3622,10 @@ class LIBCELLML_EXPORT GeneratorProfile * * Set the @c std::string for the implementation to create the algebraic variables array. * - * @param implementationCreateAlgebraicArrayMethodString The @c std::string to + * @param implementationCreateAlgebraicVariablesArrayMethodString The @c std::string to * use for the implementation to create the algebraic variables array. */ - void setImplementationCreateAlgebraicArrayMethodString(const std::string &implementationCreateAlgebraicArrayMethodString); + void setImplementationCreateAlgebraicVariablesArrayMethodString(const std::string &implementationCreateAlgebraicVariablesArrayMethodString); /** * @brief Get the @c std::string for the interface to create the external variables @@ -3635,7 +3635,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to create the external variables array. */ - std::string interfaceCreateExternalsArrayMethodString() const; + std::string interfaceCreateExternalVariablesArrayMethodString() const; /** * @brief Set the @c std::string for the interface to create the external variables @@ -3643,10 +3643,10 @@ class LIBCELLML_EXPORT GeneratorProfile * * Set the @c std::string for the interface to create the external variables array. * - * @param interfaceCreateExternalsArrayMethodString The @c std::string to use + * @param interfaceCreateExternalVariablesArrayMethodString The @c std::string to use * for the interface to create the external variables array. */ - void setInterfaceCreateExternalsArrayMethodString(const std::string &interfaceCreateExternalsArrayMethodString); + void setInterfaceCreateExternalVariablesArrayMethodString(const std::string &interfaceCreateExternalVariablesArrayMethodString); /** * @brief Get the @c std::string for the implementation to create the external variables @@ -3658,7 +3658,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation to create the external variables * array. */ - std::string implementationCreateExternalsArrayMethodString() const; + std::string implementationCreateExternalVariablesArrayMethodString() const; /** * @brief Set the @c std::string for the implementation to create the external variables @@ -3666,10 +3666,10 @@ class LIBCELLML_EXPORT GeneratorProfile * * Set the @c std::string for the implementation to create the external variables array. * - * @param implementationCreateExternalsArrayMethodString The @c std::string to + * @param implementationCreateExternalVariablesArrayMethodString The @c std::string to * use for the implementation to create the external variables array. */ - void setImplementationCreateExternalsArrayMethodString(const std::string &implementationCreateExternalsArrayMethodString); + void setImplementationCreateExternalVariablesArrayMethodString(const std::string &implementationCreateExternalVariablesArrayMethodString); /** * @brief Get the @c std::string for the interface to delete an array. diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 8194a0f49..d8db894c5 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -197,7 +197,7 @@ class LIBCELLML_EXPORT Issue ANALYSER_ODE_NOT_FIRST_ORDER, ANALYSER_VARIABLE_UNUSED, ANALYSER_STATE_NOT_INITIALISED, - ANALYSER_STATE_RATE_AS_ALGEBRAIC, + ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE, ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE, ANALYSER_EXTERNAL_VARIABLE_DIFFERENT_MODEL, ANALYSER_EXTERNAL_VARIABLE_VOI, diff --git a/src/bindings/interface/analyserequation.i b/src/bindings/interface/analyserequation.i index e75f49f9a..de3be186b 100644 --- a/src/bindings/interface/analyserequation.i +++ b/src/bindings/interface/analyserequation.i @@ -61,22 +61,22 @@ %feature("docstring") libcellml::AnalyserEquation::computedConstant "Returns the computed constant, at the given index, computed by this :class:`AnalyserEquation` object."; -%feature("docstring") libcellml::AnalyserEquation::algebraicCount +%feature("docstring") libcellml::AnalyserEquation::algebraicVariableCount "Returns the number of algebraic variables computed by this :class:`AnalyserEquation` object."; -%feature("docstring") libcellml::AnalyserEquation::algebraic +%feature("docstring") libcellml::AnalyserEquation::algebraicVariables "Returns the algebraic variables computed by this :class:`AnalyserEquation` object."; -%feature("docstring") libcellml::AnalyserEquation::algebraic +%feature("docstring") libcellml::AnalyserEquation::algebraicVariable "Returns the algebraic variable, at the given index, computed by this :class:`AnalyserEquation` object."; -%feature("docstring") libcellml::AnalyserEquation::externalCount +%feature("docstring") libcellml::AnalyserEquation::externalVariableCount "Returns the number of external variables computed by this :class:`AnalyserEquation` object."; -%feature("docstring") libcellml::AnalyserEquation::externals +%feature("docstring") libcellml::AnalyserEquation::externalVariables "Returns the external variables computed by this :class:`AnalyserEquation` object."; -%feature("docstring") libcellml::AnalyserEquation::external +%feature("docstring") libcellml::AnalyserEquation::externalVariable "Returns the external variable, at the given index, computed by this :class:`AnalyserEquation` object."; %{ diff --git a/src/bindings/interface/analysermodel.i b/src/bindings/interface/analysermodel.i index 692a9d789..de2a9039e 100644 --- a/src/bindings/interface/analysermodel.i +++ b/src/bindings/interface/analysermodel.i @@ -52,22 +52,22 @@ %feature("docstring") libcellml::AnalyserModel::computedConstant "Returns the computed constant, specified by index, contained by this :class:`AnalyserModel` object."; -%feature("docstring") libcellml::AnalyserModel::algebraicCount +%feature("docstring") libcellml::AnalyserModel::algebraicVariableCount "Returns the number of algebraic variables contained by this :class:`AnalyserModel` object."; -%feature("docstring") libcellml::AnalyserModel::algebraic +%feature("docstring") libcellml::AnalyserModel::algebraicVariables "Returns the algebraic variables contained by this :class:`AnalyserModel` object."; -%feature("docstring") libcellml::AnalyserModel::algebraic +%feature("docstring") libcellml::AnalyserModel::algebraicVariable "Returns the algebraic variable, specified by index, contained by this :class:`AnalyserModel` object."; -%feature("docstring") libcellml::AnalyserModel::externalCount +%feature("docstring") libcellml::AnalyserModel::externalVariableCount "Returns the number of external variables contained by this :class:`AnalyserModel` object."; -%feature("docstring") libcellml::AnalyserModel::externals +%feature("docstring") libcellml::AnalyserModel::externalVariables "Returns the external variables contained by this :class:`AnalyserModel` object."; -%feature("docstring") libcellml::AnalyserModel::external +%feature("docstring") libcellml::AnalyserModel::externalVariable "Returns the external variable, specified by index, contained by this :class:`AnalyserModel` object."; %feature("docstring") libcellml::AnalyserModel::equationCount diff --git a/src/bindings/interface/generatorprofile.i b/src/bindings/interface/generatorprofile.i index 62cb5f26d..791447c2e 100644 --- a/src/bindings/interface/generatorprofile.i +++ b/src/bindings/interface/generatorprofile.i @@ -703,31 +703,31 @@ the [CONSTANT_COUNT] tag, which will be replaced with the number of states in th "Sets the string for the implementation of the computed constant count constant. To be useful, the string should contain the [COMPUTED_CONSTANT_COUNT] tag, which will be replaced with the number of states in the model."; -%feature("docstring") libcellml::GeneratorProfile::interfaceAlgebraicCountString -"Returns the string for the interface of the algebraic count constant."; +%feature("docstring") libcellml::GeneratorProfile::interfaceAlgebraicVariableCountString +"Returns the string for the interface of the algebraic variable count constant."; -%feature("docstring") libcellml::GeneratorProfile::setInterfaceAlgebraicCountString -"Sets the string for the interface of the algebraic count constant."; +%feature("docstring") libcellml::GeneratorProfile::setInterfaceAlgebraicVariableCountString +"Sets the string for the interface of the algebraic variable count constant."; -%feature("docstring") libcellml::GeneratorProfile::implementationAlgebraicCountString -"Returns the string for the implementation of the algebraic count constant."; +%feature("docstring") libcellml::GeneratorProfile::implementationAlgebraicVariableCountString +"Returns the string for the implementation of the algebraic variable count constant."; -%feature("docstring") libcellml::GeneratorProfile::setImplementationAlgebraicCountString -"Sets the string for the implementation of the algebraic count constant. To be useful, the string should contain -the [ALGEBRAIC_COUNT] tag, which will be replaced with the number of states in the model."; +%feature("docstring") libcellml::GeneratorProfile::setImplementationAlgebraicVariableCountString +"Sets the string for the implementation of the algebraic variable count constant. To be useful, the string should contain +the [ALGEBRAIC_VARIABLE_COUNT] tag, which will be replaced with the number of states in the model."; -%feature("docstring") libcellml::GeneratorProfile::interfaceExternalCountString -"Returns the string for the interface of the external count constant."; +%feature("docstring") libcellml::GeneratorProfile::interfaceExternalVariableCountString +"Returns the string for the interface of the external variable count constant."; -%feature("docstring") libcellml::GeneratorProfile::setInterfaceExternalCountString -"Sets the string for the interface of the external count constant."; +%feature("docstring") libcellml::GeneratorProfile::setInterfaceExternalVariableCountString +"Sets the string for the interface of the external variable count constant."; -%feature("docstring") libcellml::GeneratorProfile::implementationExternalCountString -"Returns the string for the implementation of the external count constant."; +%feature("docstring") libcellml::GeneratorProfile::implementationExternalVariableCountString +"Returns the string for the implementation of the external variable count constant."; -%feature("docstring") libcellml::GeneratorProfile::setImplementationExternalCountString -"Sets the string for the implementation of the external count constant. To be useful, the string should contain -the [EXTERNAL_COUNT] tag, which will be replaced with the number of states in the model."; +%feature("docstring") libcellml::GeneratorProfile::setImplementationExternalVariableCountString +"Sets the string for the implementation of the external variable count constant. To be useful, the string should contain +the [EXTERNAL_VARIABLE_COUNT] tag, which will be replaced with the number of states in the model."; %feature("docstring") libcellml::GeneratorProfile::variableInfoObjectString "Returns the string for the data structure for the variable information object."; @@ -790,29 +790,29 @@ should contain the [CODE] tag, which will be replaced with some information abou "Sets the string for the implementation of some information about the different computed constants. To be useful, the string should contain the [CODE] tag, which will be replaced with some information about the different computed constants."; -%feature("docstring") libcellml::GeneratorProfile::interfaceAlgebraicInfoString +%feature("docstring") libcellml::GeneratorProfile::interfaceAlgebraicVariableInfoString "Returns the string for the interface of some information about the different algebraic variables."; -%feature("docstring") libcellml::GeneratorProfile::setInterfaceAlgebraicInfoString +%feature("docstring") libcellml::GeneratorProfile::setInterfaceAlgebraicVariableInfoString "Sets the string for the interface of some information about the different algebraic variables."; -%feature("docstring") libcellml::GeneratorProfile::implementationAlgebraicInfoString +%feature("docstring") libcellml::GeneratorProfile::implementationAlgebraicVariableInfoString "Returns the string for the implementation of some information about the different algebraic variables."; -%feature("docstring") libcellml::GeneratorProfile::setImplementationAlgebraicInfoString +%feature("docstring") libcellml::GeneratorProfile::setImplementationAlgebraicVariableInfoString "Sets the string for the implementation of some information about the different algebraic variables. To be useful, the string should contain the [CODE] tag, which will be replaced with some information about the different algebraic variables."; -%feature("docstring") libcellml::GeneratorProfile::interfaceExternalInfoString +%feature("docstring") libcellml::GeneratorProfile::interfaceExternalVariableInfoString "Returns the string for the interface of some information about the different external variables."; -%feature("docstring") libcellml::GeneratorProfile::setInterfaceExternalInfoString +%feature("docstring") libcellml::GeneratorProfile::setInterfaceExternalVariableInfoString "Sets the string for the interface of some information about the different external variables."; -%feature("docstring") libcellml::GeneratorProfile::implementationExternalInfoString +%feature("docstring") libcellml::GeneratorProfile::implementationExternalVariableInfoString "Returns the string for the implementation of some information about the different external variables."; -%feature("docstring") libcellml::GeneratorProfile::setImplementationExternalInfoString +%feature("docstring") libcellml::GeneratorProfile::setImplementationExternalVariableInfoString "Sets the string for the implementation of some information about the different external variables. To be useful, the string should contain the [CODE] tag, which will be replaced with some information about the different external variables."; @@ -854,17 +854,17 @@ and units of a variable respectively."; %feature("docstring") libcellml::GeneratorProfile::setComputedConstantsArrayString "Sets the string for the name of the computed constants array."; -%feature("docstring") libcellml::GeneratorProfile::algebraicArrayString -"Returns the string for the name of the algebraic array."; +%feature("docstring") libcellml::GeneratorProfile::algebraicVariablesArrayString +"Returns the string for the name of the algebraic variables array."; -%feature("docstring") libcellml::GeneratorProfile::setAlgebraicArrayString -"Sets the string for the name of the algebraic array."; +%feature("docstring") libcellml::GeneratorProfile::setAlgebraicVariablesArrayString +"Sets the string for the name of the algebraic variables array."; -%feature("docstring") libcellml::GeneratorProfile::externalArrayString -"Returns the string for the name of the external array."; +%feature("docstring") libcellml::GeneratorProfile::externalVariablesArrayString +"Returns the string for the name of the external variables array."; -%feature("docstring") libcellml::GeneratorProfile::setExternalArrayString -"Sets the string for the name of the external array."; +%feature("docstring") libcellml::GeneratorProfile::setExternalVariablesArrayString +"Sets the string for the name of the external variables array."; %feature("docstring") libcellml::GeneratorProfile::externalVariableMethodTypeDefinitionString "Returns the string for the type definition of an external variable method."; @@ -972,33 +972,33 @@ tag, which will be replaced with some code to create the computed constants arra "Sets the string for the implementation to create the computed constants array. To be useful, the string should contain the [CODE] tag, which will be replaced with some code to create the computed constants array."; -%feature("docstring") libcellml::GeneratorProfile::interfaceCreateAlgebraicArrayMethodString -"Returns the string for the interface to create the algebraic array."; +%feature("docstring") libcellml::GeneratorProfile::interfaceCreateAlgebraicVariablesArrayMethodString +"Returns the string for the interface to create the algebraic variables array."; -%feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateAlgebraicArrayMethodString -"Sets the string for the interface to create the algebraic array. To be useful, the string should contain the [CODE] -tag, which will be replaced with some code to create the algebraic array."; +%feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateAlgebraicVariablesArrayMethodString +"Sets the string for the interface to create the algebraic variables array. To be useful, the string should contain the [CODE] +tag, which will be replaced with some code to create the algebraic variables array."; -%feature("docstring") libcellml::GeneratorProfile::implementationCreateAlgebraicArrayMethodString -"Returns the string for the implementation to create the algebraic array."; +%feature("docstring") libcellml::GeneratorProfile::implementationCreateAlgebraicVariablesArrayMethodString +"Returns the string for the implementation to create the algebraic variables array."; -%feature("docstring") libcellml::GeneratorProfile::setImplementationCreateAlgebraicArrayMethodString -"Sets the string for the implementation to create the algebraic array. To be useful, the string should contain the -[CODE] tag, which will be replaced with some code to create the algebraic array."; +%feature("docstring") libcellml::GeneratorProfile::setImplementationCreateAlgebraicVariablesArrayMethodString +"Sets the string for the implementation to create the algebraic variables array. To be useful, the string should contain the +[CODE] tag, which will be replaced with some code to create the algebraic variables array."; -%feature("docstring") libcellml::GeneratorProfile::interfaceCreateExternalsArrayMethodString -"Returns the string for the interface to create the externals array."; +%feature("docstring") libcellml::GeneratorProfile::interfaceCreateExternalVariablesArrayMethodString +"Returns the string for the interface to create the external variables array."; -%feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateExternalsArrayMethodString -"Sets the string for the interface to create the externals array. To be useful, the string should contain the [CODE] -tag, which will be replaced with some code to create the externals array."; +%feature("docstring") libcellml::GeneratorProfile::setInterfaceCreateExternalVariablesArrayMethodString +"Sets the string for the interface to create the external variables array. To be useful, the string should contain the [CODE] +tag, which will be replaced with some code to create the external variables array."; -%feature("docstring") libcellml::GeneratorProfile::implementationCreateExternalsArrayMethodString -"Returns the string for the implementation to create the externals array."; +%feature("docstring") libcellml::GeneratorProfile::implementationCreateExternalVariablesArrayMethodString +"Returns the string for the implementation to create the external variables array."; -%feature("docstring") libcellml::GeneratorProfile::setImplementationCreateExternalsArrayMethodString -"Sets the string for the implementation to create the externals array. To be useful, the string should contain the -[CODE] tag, which will be replaced with some code to create the externals array."; +%feature("docstring") libcellml::GeneratorProfile::setImplementationCreateExternalVariablesArrayMethodString +"Sets the string for the implementation to create the external variables array. To be useful, the string should contain the +[CODE] tag, which will be replaced with some code to create the external variables array."; %feature("docstring") libcellml::GeneratorProfile::interfaceDeleteArrayMethodString "Returns the string for the interface to delete an array."; diff --git a/src/bindings/interface/types.i b/src/bindings/interface/types.i index 01c6b8c17..b216b8a78 100644 --- a/src/bindings/interface/types.i +++ b/src/bindings/interface/types.i @@ -157,7 +157,7 @@ Provides support for shared pointers declared in types.h. if (!SWIG_IsOK(ecode)) { %argument_fail(ecode, "$type", $symname, $argnum); } else { - if (val < %static_cast($type::VARIABLE_OF_INTEGRATION, int) || %static_cast($type::EXTERNAL, int) < val) { + if (val < %static_cast($type::VARIABLE_OF_INTEGRATION, int) || %static_cast($type::EXTERNAL_VARIABLE, int) < val) { %argument_fail(ecode, "$type is not a valid value for the enumeration.", $symname, $argnum); } $1 = %static_cast(val, $basetype); diff --git a/src/bindings/javascript/analyserequation.cpp b/src/bindings/javascript/analyserequation.cpp index 5f428b040..2b4231589 100644 --- a/src/bindings/javascript/analyserequation.cpp +++ b/src/bindings/javascript/analyserequation.cpp @@ -46,17 +46,17 @@ EMSCRIPTEN_BINDINGS(libcellml_analyserequation) .function("nlaSibling", &libcellml::AnalyserEquation::nlaSibling) .function("isStateRateBased", &libcellml::AnalyserEquation::isStateRateBased) .function("stateCount", &libcellml::AnalyserEquation::stateCount) - .function("states", select_overload() const>(&libcellml::AnalyserEquation::states)) - .function("state", select_overload(&libcellml::AnalyserEquation::state)) + .function("states", &libcellml::AnalyserEquation::states) + .function("state", &libcellml::AnalyserEquation::state) .function("computedConstantCount", &libcellml::AnalyserEquation::computedConstantCount) .function("computedConstants", &libcellml::AnalyserEquation::computedConstants) .function("computedConstant", &libcellml::AnalyserEquation::computedConstant) - .function("algebraicCount", &libcellml::AnalyserEquation::algebraicCount) - .function("algebraicVariables", select_overload() const>(&libcellml::AnalyserEquation::algebraic)) - .function("algebraicVariable", select_overload(&libcellml::AnalyserEquation::algebraic)) - .function("externalCount", &libcellml::AnalyserEquation::externalCount) - .function("externals", select_overload() const>(&libcellml::AnalyserEquation::externals)) - .function("external", select_overload(&libcellml::AnalyserEquation::external)) + .function("algebraicVariableCount", &libcellml::AnalyserEquation::algebraicVariableCount) + .function("algebraicVariables", &libcellml::AnalyserEquation::algebraicVariables) + .function("algebraicVariable", &libcellml::AnalyserEquation::algebraicVariable) + .function("externalVariableCount", &libcellml::AnalyserEquation::externalVariableCount) + .function("externalVariables", &libcellml::AnalyserEquation::externalVariables) + .function("externalVariable", &libcellml::AnalyserEquation::externalVariable) ; EM_ASM( diff --git a/src/bindings/javascript/analysermodel.cpp b/src/bindings/javascript/analysermodel.cpp index 5182aa89b..fcb759d42 100644 --- a/src/bindings/javascript/analysermodel.cpp +++ b/src/bindings/javascript/analysermodel.cpp @@ -51,12 +51,12 @@ EMSCRIPTEN_BINDINGS(libcellml_analysermodel) .function("computedConstantCount", &libcellml::AnalyserModel::computedConstantCount) .function("computedConstants", &libcellml::AnalyserModel::computedConstants) .function("computedConstant", &libcellml::AnalyserModel::computedConstant) - .function("algebraicCount", &libcellml::AnalyserModel::algebraicCount) - .function("algebraicVariables", select_overload() const>(&libcellml::AnalyserModel::algebraic)) - .function("algebraicVariable", select_overload(&libcellml::AnalyserModel::algebraic)) - .function("externalCount", &libcellml::AnalyserModel::externalCount) - .function("externals", select_overload() const>(&libcellml::AnalyserModel::externals)) - .function("external", select_overload(&libcellml::AnalyserModel::external)) + .function("algebraicVariableCount", &libcellml::AnalyserModel::algebraicVariableCount) + .function("algebraicVariables", &libcellml::AnalyserModel::algebraicVariables) + .function("algebraicVariable", &libcellml::AnalyserModel::algebraicVariable) + .function("externalVariableCount", &libcellml::AnalyserModel::externalVariableCount) + .function("externalVariables", &libcellml::AnalyserModel::externalVariables) + .function("externalVariable", &libcellml::AnalyserModel::externalVariable) .function("equationCount", &libcellml::AnalyserModel::equationCount) .function("equations", &libcellml::AnalyserModel::equations) .function("equation", &libcellml::AnalyserModel::equation) diff --git a/src/bindings/javascript/analyservariable.cpp b/src/bindings/javascript/analyservariable.cpp index 0462c5a61..81c5c633c 100644 --- a/src/bindings/javascript/analyservariable.cpp +++ b/src/bindings/javascript/analyservariable.cpp @@ -28,8 +28,8 @@ EMSCRIPTEN_BINDINGS(libcellml_analyservariable) .value("STATE", libcellml::AnalyserVariable::Type::STATE) .value("CONSTANT", libcellml::AnalyserVariable::Type::CONSTANT) .value("COMPUTED_CONSTANT", libcellml::AnalyserVariable::Type::COMPUTED_CONSTANT) - .value("ALGEBRAIC", libcellml::AnalyserVariable::Type::ALGEBRAIC) - .value("EXTERNAL", libcellml::AnalyserVariable::Type::EXTERNAL) + .value("ALGEBRAIC_VARIABLE", libcellml::AnalyserVariable::Type::ALGEBRAIC_VARIABLE) + .value("EXTERNAL_VARIABLE", libcellml::AnalyserVariable::Type::EXTERNAL_VARIABLE) ; class_("AnalyserVariable") diff --git a/src/bindings/javascript/generatorprofile.cpp b/src/bindings/javascript/generatorprofile.cpp index e981e701e..5a006d252 100644 --- a/src/bindings/javascript/generatorprofile.cpp +++ b/src/bindings/javascript/generatorprofile.cpp @@ -259,14 +259,14 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setInterfaceComputedConstantCountString", &libcellml::GeneratorProfile::setInterfaceComputedConstantCountString) .function("implementationComputedConstantCountString", &libcellml::GeneratorProfile::implementationComputedConstantCountString) .function("setImplementationComputedConstantCountString", &libcellml::GeneratorProfile::setImplementationComputedConstantCountString) - .function("interfaceAlgebraicCountString", &libcellml::GeneratorProfile::interfaceAlgebraicCountString) - .function("setInterfaceAlgebraicCountString", &libcellml::GeneratorProfile::setInterfaceAlgebraicCountString) - .function("implementationAlgebraicCountString", &libcellml::GeneratorProfile::implementationAlgebraicCountString) - .function("setImplementationAlgebraicCountString", &libcellml::GeneratorProfile::setImplementationAlgebraicCountString) - .function("interfaceExternalCountString", &libcellml::GeneratorProfile::interfaceExternalCountString) - .function("setInterfaceExternalCountString", &libcellml::GeneratorProfile::setInterfaceExternalCountString) - .function("implementationExternalCountString", &libcellml::GeneratorProfile::implementationExternalCountString) - .function("setImplementationExternalCountString", &libcellml::GeneratorProfile::setImplementationExternalCountString) + .function("interfaceAlgebraicVariableCountString", &libcellml::GeneratorProfile::interfaceAlgebraicVariableCountString) + .function("setInterfaceAlgebraicVariableCountString", &libcellml::GeneratorProfile::setInterfaceAlgebraicVariableCountString) + .function("implementationAlgebraicVariableCountString", &libcellml::GeneratorProfile::implementationAlgebraicVariableCountString) + .function("setImplementationAlgebraicVariableCountString", &libcellml::GeneratorProfile::setImplementationAlgebraicVariableCountString) + .function("interfaceExternalVariableCountString", &libcellml::GeneratorProfile::interfaceExternalVariableCountString) + .function("setInterfaceExternalVariableCountString", &libcellml::GeneratorProfile::setInterfaceExternalVariableCountString) + .function("implementationExternalVariableCountString", &libcellml::GeneratorProfile::implementationExternalVariableCountString) + .function("setImplementationExternalVariableCountString", &libcellml::GeneratorProfile::setImplementationExternalVariableCountString) .function("variableInfoObjectString", &libcellml::GeneratorProfile::variableInfoObjectString) .function("setVariableInfoObjectString", &libcellml::GeneratorProfile::setVariableInfoObjectString) .function("interfaceVoiInfoString", &libcellml::GeneratorProfile::interfaceVoiInfoString) @@ -285,14 +285,14 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setInterfaceComputedConstantInfoString", &libcellml::GeneratorProfile::setInterfaceComputedConstantInfoString) .function("implementationComputedConstantInfoString", &libcellml::GeneratorProfile::implementationComputedConstantInfoString) .function("setImplementationComputedConstantInfoString", &libcellml::GeneratorProfile::setImplementationComputedConstantInfoString) - .function("interfaceAlgebraicInfoString", &libcellml::GeneratorProfile::interfaceAlgebraicInfoString) - .function("setInterfaceAlgebraicInfoString", &libcellml::GeneratorProfile::setInterfaceAlgebraicInfoString) - .function("implementationAlgebraicInfoString", &libcellml::GeneratorProfile::implementationAlgebraicInfoString) - .function("setImplementationAlgebraicInfoString", &libcellml::GeneratorProfile::setImplementationAlgebraicInfoString) - .function("interfaceExternalInfoString", &libcellml::GeneratorProfile::interfaceExternalInfoString) - .function("setInterfaceExternalInfoString", &libcellml::GeneratorProfile::setInterfaceExternalInfoString) - .function("implementationExternalInfoString", &libcellml::GeneratorProfile::implementationExternalInfoString) - .function("setImplementationExternalInfoString", &libcellml::GeneratorProfile::setImplementationExternalInfoString) + .function("interfaceAlgebraicVariableInfoString", &libcellml::GeneratorProfile::interfaceAlgebraicVariableInfoString) + .function("setInterfaceAlgebraicVariableInfoString", &libcellml::GeneratorProfile::setInterfaceAlgebraicVariableInfoString) + .function("implementationAlgebraicVariableInfoString", &libcellml::GeneratorProfile::implementationAlgebraicVariableInfoString) + .function("setImplementationAlgebraicVariableInfoString", &libcellml::GeneratorProfile::setImplementationAlgebraicVariableInfoString) + .function("interfaceExternalVariableInfoString", &libcellml::GeneratorProfile::interfaceExternalVariableInfoString) + .function("setInterfaceExternalVariableInfoString", &libcellml::GeneratorProfile::setInterfaceExternalVariableInfoString) + .function("implementationExternalVariableInfoString", &libcellml::GeneratorProfile::implementationExternalVariableInfoString) + .function("setImplementationExternalVariableInfoString", &libcellml::GeneratorProfile::setImplementationExternalVariableInfoString) .function("variableInfoEntryString", &libcellml::GeneratorProfile::variableInfoEntryString) .function("setVariableInfoEntryString", &libcellml::GeneratorProfile::setVariableInfoEntryString) .function("voiString", &libcellml::GeneratorProfile::voiString) @@ -305,10 +305,10 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setConstantsArrayString", &libcellml::GeneratorProfile::setConstantsArrayString) .function("computedConstantsArrayString", &libcellml::GeneratorProfile::computedConstantsArrayString) .function("setComputedConstantsArrayString", &libcellml::GeneratorProfile::setComputedConstantsArrayString) - .function("algebraicArrayString", &libcellml::GeneratorProfile::algebraicArrayString) - .function("setAlgebraicArrayString", &libcellml::GeneratorProfile::setAlgebraicArrayString) - .function("externalArrayString", &libcellml::GeneratorProfile::externalArrayString) - .function("setExternalArrayString", &libcellml::GeneratorProfile::setExternalArrayString) + .function("algebraicVariablesArrayString", &libcellml::GeneratorProfile::algebraicVariablesArrayString) + .function("setAlgebraicVariablesArrayString", &libcellml::GeneratorProfile::setAlgebraicVariablesArrayString) + .function("externalVariablesArrayString", &libcellml::GeneratorProfile::externalVariablesArrayString) + .function("setExternalVariablesArrayString", &libcellml::GeneratorProfile::setExternalVariablesArrayString) .function("externalVariableMethodTypeDefinitionString", &libcellml::GeneratorProfile::externalVariableMethodTypeDefinitionString) .function("setExternalVariableMethodTypeDefinitionString", &libcellml::GeneratorProfile::setExternalVariableMethodTypeDefinitionString) .function("externalVariableMethodCallString", &libcellml::GeneratorProfile::externalVariableMethodCallString) @@ -341,14 +341,14 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setInterfaceCreateComputedConstantsArrayMethodString", &libcellml::GeneratorProfile::setInterfaceCreateComputedConstantsArrayMethodString) .function("implementationCreateComputedConstantsArrayMethodString", &libcellml::GeneratorProfile::implementationCreateComputedConstantsArrayMethodString) .function("setImplementationCreateComputedConstantsArrayMethodString", &libcellml::GeneratorProfile::setImplementationCreateComputedConstantsArrayMethodString) - .function("interfaceCreateAlgebraicArrayMethodString", &libcellml::GeneratorProfile::interfaceCreateAlgebraicArrayMethodString) - .function("setInterfaceCreateAlgebraicArrayMethodString", &libcellml::GeneratorProfile::setInterfaceCreateAlgebraicArrayMethodString) - .function("implementationCreateAlgebraicArrayMethodString", &libcellml::GeneratorProfile::implementationCreateAlgebraicArrayMethodString) - .function("setImplementationCreateAlgebraicArrayMethodString", &libcellml::GeneratorProfile::setImplementationCreateAlgebraicArrayMethodString) - .function("interfaceCreateExternalsArrayMethodString", &libcellml::GeneratorProfile::interfaceCreateExternalsArrayMethodString) - .function("setInterfaceCreateExternalsArrayMethodString", &libcellml::GeneratorProfile::setInterfaceCreateExternalsArrayMethodString) - .function("implementationCreateExternalsArrayMethodString", &libcellml::GeneratorProfile::implementationCreateExternalsArrayMethodString) - .function("setImplementationCreateExternalsArrayMethodString", &libcellml::GeneratorProfile::setImplementationCreateExternalsArrayMethodString) + .function("interfaceCreateAlgebraicVariablesArrayMethodString", &libcellml::GeneratorProfile::interfaceCreateAlgebraicVariablesArrayMethodString) + .function("setInterfaceCreateAlgebraicVariablesArrayMethodString", &libcellml::GeneratorProfile::setInterfaceCreateAlgebraicVariablesArrayMethodString) + .function("implementationCreateAlgebraicVariablesArrayMethodString", &libcellml::GeneratorProfile::implementationCreateAlgebraicVariablesArrayMethodString) + .function("setImplementationCreateAlgebraicVariablesArrayMethodString", &libcellml::GeneratorProfile::setImplementationCreateAlgebraicVariablesArrayMethodString) + .function("interfaceCreateExternalVariablesArrayMethodString", &libcellml::GeneratorProfile::interfaceCreateExternalVariablesArrayMethodString) + .function("setInterfaceCreateExternalVariablesArrayMethodString", &libcellml::GeneratorProfile::setInterfaceCreateExternalVariablesArrayMethodString) + .function("implementationCreateExternalVariablesArrayMethodString", &libcellml::GeneratorProfile::implementationCreateExternalVariablesArrayMethodString) + .function("setImplementationCreateExternalVariablesArrayMethodString", &libcellml::GeneratorProfile::setImplementationCreateExternalVariablesArrayMethodString) .function("interfaceDeleteArrayMethodString", &libcellml::GeneratorProfile::interfaceDeleteArrayMethodString) .function("setInterfaceDeleteArrayMethodString", &libcellml::GeneratorProfile::setInterfaceDeleteArrayMethodString) .function("implementationDeleteArrayMethodString", &libcellml::GeneratorProfile::implementationDeleteArrayMethodString) diff --git a/src/bindings/javascript/issue.cpp b/src/bindings/javascript/issue.cpp index 01a14768b..e1422221c 100644 --- a/src/bindings/javascript/issue.cpp +++ b/src/bindings/javascript/issue.cpp @@ -36,7 +36,7 @@ EMSCRIPTEN_BINDINGS(libcellml_issue) { .value("ANALYSER_EXTERNAL_VARIABLE_VOI", libcellml::Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_VOI) .value("ANALYSER_ODE_NOT_FIRST_ORDER", libcellml::Issue::ReferenceRule::ANALYSER_ODE_NOT_FIRST_ORDER) .value("ANALYSER_STATE_NOT_INITIALISED", libcellml::Issue::ReferenceRule::ANALYSER_STATE_NOT_INITIALISED) - .value("ANALYSER_STATE_RATE_AS_ALGEBRAIC", libcellml::Issue::ReferenceRule::ANALYSER_STATE_RATE_AS_ALGEBRAIC) + .value("ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE", libcellml::Issue::ReferenceRule::ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE) .value("ANALYSER_UNITS", libcellml::Issue::ReferenceRule::ANALYSER_UNITS) .value("ANALYSER_UNLINKED_UNITS", libcellml::Issue::ReferenceRule::ANALYSER_UNLINKED_UNITS) .value("ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE) diff --git a/src/bindings/python/__init__.py b/src/bindings/python/__init__.py index d2ca733cf..2432d944a 100644 --- a/src/bindings/python/__init__.py +++ b/src/bindings/python/__init__.py @@ -169,8 +169,8 @@ class Object: 'STATE', 'CONSTANT', 'COMPUTED_CONSTANT', - 'ALGEBRAIC', - 'EXTERNAL', + 'ALGEBRAIC_VARIABLE', + 'EXTERNAL_VARIABLE', ]) convert(GeneratorProfile, 'Profile', [ 'C', @@ -316,7 +316,7 @@ class Object: 'ANALYSER_ODE_NOT_FIRST_ORDER', 'ANALYSER_VARIABLE_UNUSED', 'ANALYSER_STATE_NOT_INITIALISED', - 'ANALYSER_STATE_RATE_AS_ALGEBRAIC', + 'ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE', 'ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE', 'ANALYSER_EXTERNAL_VARIABLE_DIFFERENT_MODEL', 'ANALYSER_EXTERNAL_VARIABLE_VOI', diff --git a/src/debug.cpp b/src/debug.cpp index 819f79c16..e431719af 100644 --- a/src/debug.cpp +++ b/src/debug.cpp @@ -106,21 +106,21 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) Debug() << "\nNo computed constants"; } - if (eqn->algebraicCount() != 0) { + if (eqn->algebraicVariableCount() != 0) { Debug() << "\nAlgebraic variables:"; - for (const auto &var : eqn->algebraic()) { - Debug() << " - " << var->variable()->name(); + for (const auto &algVar : eqn->algebraicVariables()) { + Debug() << " - " << algVar->variable()->name(); } } else { Debug() << "\nNo algebraic variables"; } - if (eqn->externalCount() != 0) { + if (eqn->externalVariableCount() != 0) { Debug() << "\nExternal variables:"; - for (const auto &var : eqn->externals()) { - Debug() << " - " << var->variable()->name(); + for (const auto &extVar : eqn->externalVariables()) { + Debug() << " - " << extVar->variable()->name(); } } else { Debug() << "\nNo external variables"; @@ -133,7 +133,7 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) if (dep->ast() != nullptr) { Debug() << " - " << astAsCode(dep->ast()); } else if (dep->type() == AnalyserEquation::Type::EXTERNAL) { - Debug() << " - External equation for '" << dep->external(0)->variable()->name() << "'"; + Debug() << " - External equation for '" << dep->externalVariable(0)->variable()->name() << "'"; } else { Debug() << " - ??? [" << AnalyserEquation::typeAsString(dep->type()) << "]"; } @@ -150,7 +150,7 @@ void printAnalyserModelEquations(const AnalyserModelPtr &model) if (nlaSibling->ast() != nullptr) { Debug() << " - " << astAsCode(nlaSibling->ast()); } else if (nlaSibling->type() == AnalyserEquation::Type::EXTERNAL) { - Debug() << " - External equation for '" << nlaSibling->external(0)->variable()->name() << "'"; + Debug() << " - External equation for '" << nlaSibling->externalVariable(0)->variable()->name() << "'"; } else { Debug() << " - ??? [" << AnalyserEquation::typeAsString(nlaSibling->type()) << "]"; } @@ -180,7 +180,7 @@ void printAnalyserModelVariables(const AnalyserModelPtr &model) if (eqn->ast() != nullptr) { Debug() << " - " << astAsCode(eqn->ast()); } else if (eqn->type() == AnalyserEquation::Type::EXTERNAL) { - Debug() << " - External equation for '" << eqn->external(0)->variable()->name() << "'"; + Debug() << " - External equation for '" << eqn->externalVariable(0)->variable()->name() << "'"; } else { Debug() << " - ??? [" << AnalyserEquation::typeAsString(eqn->type()) << "]"; } diff --git a/src/generator.cpp b/src/generator.cpp index d6bd71bfb..ac5eb9c88 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -356,21 +356,21 @@ void Generator::GeneratorImpl::addStateAndVariableCountCode(bool interface) "[COMPUTED_CONSTANT_COUNT]", std::to_string(mModel->computedConstantCount())); } - if ((interface && !mProfile->interfaceAlgebraicCountString().empty()) - || (!interface && !mProfile->implementationAlgebraicCountString().empty())) { + if ((interface && !mProfile->interfaceAlgebraicVariableCountString().empty()) + || (!interface && !mProfile->implementationAlgebraicVariableCountString().empty())) { code += interface ? - mProfile->interfaceAlgebraicCountString() : - replace(mProfile->implementationAlgebraicCountString(), - "[ALGEBRAIC_COUNT]", std::to_string(mModel->algebraicCount())); + mProfile->interfaceAlgebraicVariableCountString() : + replace(mProfile->implementationAlgebraicVariableCountString(), + "[ALGEBRAIC_VARIABLE_COUNT]", std::to_string(mModel->algebraicVariableCount())); } - if ((mModel->externalCount() != 0) - && ((interface && !mProfile->interfaceExternalCountString().empty()) - || (!interface && !mProfile->implementationExternalCountString().empty()))) { + if ((mModel->externalVariableCount() != 0) + && ((interface && !mProfile->interfaceExternalVariableCountString().empty()) + || (!interface && !mProfile->implementationExternalVariableCountString().empty()))) { code += interface ? - mProfile->interfaceExternalCountString() : - replace(mProfile->implementationExternalCountString(), - "[EXTERNAL_COUNT]", std::to_string(mModel->externalCount())); + mProfile->interfaceExternalVariableCountString() : + replace(mProfile->implementationExternalVariableCountString(), + "[EXTERNAL_VARIABLE_COUNT]", std::to_string(mModel->externalVariableCount())); } if (!code.empty()) { @@ -435,13 +435,13 @@ void Generator::GeneratorImpl::addInterfaceVariableInfoCode() code += mProfile->interfaceComputedConstantInfoString(); } - if (!mProfile->interfaceAlgebraicInfoString().empty()) { - code += mProfile->interfaceAlgebraicInfoString(); + if (!mProfile->interfaceAlgebraicVariableInfoString().empty()) { + code += mProfile->interfaceAlgebraicVariableInfoString(); } if (mModel->hasExternalVariables() - && !mProfile->interfaceExternalInfoString().empty()) { - code += mProfile->interfaceExternalInfoString(); + && !mProfile->interfaceExternalVariableInfoString().empty()) { + code += mProfile->interfaceExternalVariableInfoString(); } if (!code.empty()) { @@ -493,10 +493,10 @@ void Generator::GeneratorImpl::addImplementationVariableInfoCode() doAddImplementationVariableInfoCode(mProfile->implementationConstantInfoString(), mModel->constants(), false); doAddImplementationVariableInfoCode(mProfile->implementationComputedConstantInfoString(), mModel->computedConstants(), false); - doAddImplementationVariableInfoCode(mProfile->implementationAlgebraicInfoString(), mModel->algebraic(), false); + doAddImplementationVariableInfoCode(mProfile->implementationAlgebraicVariableInfoString(), mModel->algebraicVariables(), false); if (mModel->hasExternalVariables()) { - doAddImplementationVariableInfoCode(mProfile->implementationExternalInfoString(), mModel->externals(), false); + doAddImplementationVariableInfoCode(mProfile->implementationExternalVariableInfoString(), mModel->externalVariables(), false); } } @@ -667,13 +667,13 @@ void Generator::GeneratorImpl::addInterfaceCreateDeleteArrayMethodsCode() code += mProfile->interfaceCreateComputedConstantsArrayMethodString(); } - if (!mProfile->interfaceCreateAlgebraicArrayMethodString().empty()) { - code += mProfile->interfaceCreateAlgebraicArrayMethodString(); + if (!mProfile->interfaceCreateAlgebraicVariablesArrayMethodString().empty()) { + code += mProfile->interfaceCreateAlgebraicVariablesArrayMethodString(); } if (mModel->hasExternalVariables() - && !mProfile->interfaceCreateExternalsArrayMethodString().empty()) { - code += mProfile->interfaceCreateExternalsArrayMethodString(); + && !mProfile->interfaceCreateExternalVariablesArrayMethodString().empty()) { + code += mProfile->interfaceCreateExternalVariablesArrayMethodString(); } if (!mProfile->interfaceDeleteArrayMethodString().empty()) { @@ -705,15 +705,15 @@ void Generator::GeneratorImpl::addImplementationCreateDeleteArrayMethodsCode() + mProfile->implementationCreateComputedConstantsArrayMethodString(); } - if (!mProfile->implementationCreateAlgebraicArrayMethodString().empty()) { + if (!mProfile->implementationCreateAlgebraicVariablesArrayMethodString().empty()) { mCode += newLineIfNeeded() - + mProfile->implementationCreateAlgebraicArrayMethodString(); + + mProfile->implementationCreateAlgebraicVariablesArrayMethodString(); } if (mModel->hasExternalVariables() - && !mProfile->implementationCreateExternalsArrayMethodString().empty()) { + && !mProfile->implementationCreateExternalVariablesArrayMethodString().empty()) { mCode += newLineIfNeeded() - + mProfile->implementationCreateExternalsArrayMethodString(); + + mProfile->implementationCreateExternalVariablesArrayMethodString(); } if (!mProfile->implementationDeleteArrayMethodString().empty()) { @@ -773,7 +773,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() for (const auto &variable : variables) { auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - mProfile->algebraicArrayString(); + mProfile->algebraicVariablesArrayString(); methodBody += mProfile->indentString() + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() @@ -816,7 +816,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() for (const auto &variable : variables) { auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - mProfile->algebraicArrayString(); + mProfile->algebraicVariablesArrayString(); methodBody += mProfile->indentString() + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() @@ -840,7 +840,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() for (const auto &variable : variables) { auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : - mProfile->algebraicArrayString(); + mProfile->algebraicVariablesArrayString(); methodBody += mProfile->indentString() + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() @@ -923,10 +923,10 @@ std::string Generator::GeneratorImpl::generateVariableNameCode(const VariablePtr arrayName = mProfile->constantsArrayString(); } else if (analyserVariable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) { arrayName = mProfile->computedConstantsArrayString(); - } else if (analyserVariable->type() == AnalyserVariable::Type::ALGEBRAIC) { - arrayName = mProfile->algebraicArrayString(); + } else if (analyserVariable->type() == AnalyserVariable::Type::ALGEBRAIC_VARIABLE) { + arrayName = mProfile->algebraicVariablesArrayString(); } else { - arrayName = mProfile->externalArrayString(); + arrayName = mProfile->externalVariablesArrayString(); } return arrayName + mProfile->openArrayString() + convertToString(analyserVariable->index()) + mProfile->closeArrayString(); @@ -1897,11 +1897,11 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st // using an NLA system for which we need an initial guess. We use an initial guess of zero, which is fine // since such an NLA system has only one solution. - for (const auto &algebraic : mModel->algebraic()) { - if (algebraic->initialisingVariable() != nullptr) { - methodBody += generateInitialisationCode(algebraic); - } else if (algebraic->equation(0)->type() == AnalyserEquation::Type::NLA) { - methodBody += generateZeroInitialisationCode(algebraic); + for (const auto &algebraicVariable : mModel->algebraicVariables()) { + if (algebraicVariable->initialisingVariable() != nullptr) { + methodBody += generateInitialisationCode(algebraicVariable); + } else if (algebraicVariable->equation(0)->type() == AnalyserEquation::Type::NLA) { + methodBody += generateZeroInitialisationCode(algebraicVariable); } } diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 2d1a11d2f..353a1da06 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -239,11 +239,11 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceComputedConstantCountString = "extern const size_t COMPUTED_CONSTANT_COUNT;\n"; mImplementationComputedConstantCountString = "const size_t COMPUTED_CONSTANT_COUNT = [COMPUTED_CONSTANT_COUNT];\n"; - mInterfaceAlgebraicCountString = "extern const size_t ALGEBRAIC_COUNT;\n"; - mImplementationAlgebraicCountString = "const size_t ALGEBRAIC_COUNT = [ALGEBRAIC_COUNT];\n"; + mInterfaceAlgebraicVariableCountString = "extern const size_t ALGEBRAIC_VARIABLE_COUNT;\n"; + mImplementationAlgebraicVariableCountString = "const size_t ALGEBRAIC_VARIABLE_COUNT = [ALGEBRAIC_VARIABLE_COUNT];\n"; - mInterfaceExternalCountString = "extern const size_t EXTERNAL_COUNT;\n"; - mImplementationExternalCountString = "const size_t EXTERNAL_COUNT = [EXTERNAL_COUNT];\n"; + mInterfaceExternalVariableCountString = "extern const size_t EXTERNAL_VARIABLE_COUNT;\n"; + mImplementationExternalVariableCountString = "const size_t EXTERNAL_VARIABLE_COUNT = [EXTERNAL_VARIABLE_COUNT];\n"; mVariableInfoObjectString = "typedef struct {\n" " char name[[NAME_SIZE]];\n" @@ -269,15 +269,15 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "};\n"; - mInterfaceAlgebraicInfoString = "extern const VariableInfo ALGEBRAIC_INFO[];\n"; - mImplementationAlgebraicInfoString = "const VariableInfo ALGEBRAIC_INFO[] = {\n" - "[CODE]" - "};\n"; + mInterfaceAlgebraicVariableInfoString = "extern const VariableInfo ALGEBRAIC_INFO[];\n"; + mImplementationAlgebraicVariableInfoString = "const VariableInfo ALGEBRAIC_INFO[] = {\n" + "[CODE]" + "};\n"; - mInterfaceExternalInfoString = "extern const VariableInfo EXTERNAL_INFO[];\n"; - mImplementationExternalInfoString = "const VariableInfo EXTERNAL_INFO[] = {\n" - "[CODE]" - "};\n"; + mInterfaceExternalVariableInfoString = "extern const VariableInfo EXTERNAL_INFO[];\n"; + mImplementationExternalVariableInfoString = "const VariableInfo EXTERNAL_INFO[] = {\n" + "[CODE]" + "};\n"; mVariableInfoEntryString = "{\"[NAME]\", \"[UNITS]\", \"[COMPONENT]\"}"; @@ -287,25 +287,25 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mRatesArrayString = "rates"; mConstantsArrayString = "constants"; mComputedConstantsArrayString = "computedConstants"; - mAlgebraicArrayString = "algebraic"; - mExternalArrayString = "externals"; + mAlgebraicVariablesArrayString = "algebraicVariables"; + mExternalVariablesArrayString = "externalVariables"; - mExternalVariableMethodTypeDefinitionFamString = "typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n"; - mExternalVariableMethodTypeDefinitionFdmString = "typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n"; + mExternalVariableMethodTypeDefinitionFamString = "typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index);\n"; + mExternalVariableMethodTypeDefinitionFdmString = "typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index);\n"; - mExternalVariableMethodCallFamString = "externalVariable(constants, computedConstants, algebraic, externals, [INDEX])"; - mExternalVariableMethodCallFdmString = "externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, [INDEX])"; + mExternalVariableMethodCallFamString = "externalVariable(constants, computedConstants, algebraicVariables, externalVariables, [INDEX])"; + mExternalVariableMethodCallFdmString = "externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, [INDEX])"; mRootFindingInfoObjectFamWoevString = "typedef struct {\n" " double *constants;\n" " double *computedConstants;\n" - " double *algebraic;\n" + " double *algebraicVariables;\n" "} RootFindingInfo;\n"; mRootFindingInfoObjectFamWevString = "typedef struct {\n" " double *constants;\n" " double *computedConstants;\n" - " double *algebraic;\n" - " double *externals;\n" + " double *algebraicVariables;\n" + " double *externalVariables;\n" "} RootFindingInfo;\n"; mRootFindingInfoObjectFdmWoevString = "typedef struct {\n" " double voi;\n" @@ -313,7 +313,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " double *rates;\n" " double *constants;\n" " double *computedConstants;\n" - " double *algebraic;\n" + " double *algebraicVariables;\n" "} RootFindingInfo;\n"; mRootFindingInfoObjectFdmWevString = "typedef struct {\n" " double voi;\n" @@ -321,42 +321,42 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " double *rates;\n" " double *constants;\n" " double *computedConstants;\n" - " double *algebraic;\n" - " double *externals;\n" + " double *algebraicVariables;\n" + " double *externalVariables;\n" "} RootFindingInfo;\n"; mExternNlaSolveMethodString = "extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *),\n" " double *u, size_t n, void *data);\n"; - mFindRootCallFamWoevString = "findRoot[INDEX](constants, computedConstants, algebraic);\n"; - mFindRootCallFamWevString = "findRoot[INDEX](constants, computedConstants, algebraic, externals);\n"; - mFindRootCallFdmWoevString = "findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic);\n"; - mFindRootCallFdmWevString = "findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic, externals);\n"; + mFindRootCallFamWoevString = "findRoot[INDEX](constants, computedConstants, algebraicVariables);\n"; + mFindRootCallFamWevString = "findRoot[INDEX](constants, computedConstants, algebraicVariables, externalVariables);\n"; + mFindRootCallFdmWoevString = "findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraicVariables);\n"; + mFindRootCallFdmWevString = "findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables);\n"; - mFindRootMethodFamWoevString = "void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic)\n" + mFindRootMethodFamWoevString = "void findRoot[INDEX](double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" - " RootFindingInfo rfi = { constants, computedConstants, algebraic };\n" + " RootFindingInfo rfi = { constants, computedConstants, algebraicVariables };\n" " double u[[SIZE]];\n" "\n" "[CODE]" "}\n"; - mFindRootMethodFamWevString = "void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic, double *externals)\n" + mFindRootMethodFamWevString = "void findRoot[INDEX](double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables)\n" "{\n" - " RootFindingInfo rfi = { constants, computedConstants, algebraic, externals };\n" + " RootFindingInfo rfi = { constants, computedConstants, algebraicVariables, externalVariables };\n" " double u[[SIZE]];\n" "\n" "[CODE]" "}\n"; - mFindRootMethodFdmWoevString = "void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + mFindRootMethodFdmWoevString = "void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" - " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic };\n" + " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables };\n" " double u[[SIZE]];\n" "\n" "[CODE]" "}\n"; - mFindRootMethodFdmWevString = "void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals)\n" + mFindRootMethodFdmWevString = "void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables)\n" "{\n" - " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals };\n" + " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables };\n" " double u[[SIZE]];\n" "\n" "[CODE]" @@ -371,7 +371,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "{\n" " double *constants = ((RootFindingInfo *) data)->constants;\n" " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" - " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" + " double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n" "\n" "[CODE]" "}\n"; @@ -379,8 +379,8 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "{\n" " double *constants = ((RootFindingInfo *) data)->constants;\n" " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" - " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" - " double *externals = ((RootFindingInfo *) data)->externals;\n" + " double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n" + " double *externalVariables = ((RootFindingInfo *) data)->externalVariables;\n" "\n" "[CODE]" "}\n"; @@ -391,7 +391,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " double *rates = ((RootFindingInfo *) data)->rates;\n" " double *constants = ((RootFindingInfo *) data)->constants;\n" " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" - " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" + " double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n" "\n" "[CODE]" "}\n"; @@ -402,8 +402,8 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " double *rates = ((RootFindingInfo *) data)->rates;\n" " double *constants = ((RootFindingInfo *) data)->constants;\n" " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" - " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" - " double *externals = ((RootFindingInfo *) data)->externals;\n" + " double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n" + " double *externalVariables = ((RootFindingInfo *) data)->externalVariables;\n" "\n" "[CODE]" "}\n"; @@ -447,29 +447,29 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " return res;\n" "}\n"; - mInterfaceCreateAlgebraicArrayMethodString = "double * createAlgebraicArray();\n"; - mImplementationCreateAlgebraicArrayMethodString = "double * createAlgebraicArray()\n" - "{\n" - " double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double));\n" - "\n" - " for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) {\n" - " res[i] = NAN;\n" - " }\n" - "\n" - " return res;\n" - "}\n"; - - mInterfaceCreateExternalsArrayMethodString = "double * createExternalsArray();\n"; - mImplementationCreateExternalsArrayMethodString = "double * createExternalsArray()\n" - "{\n" - " double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double));\n" - "\n" - " for (size_t i = 0; i < EXTERNAL_COUNT; ++i) {\n" - " res[i] = NAN;\n" - " }\n" - "\n" - " return res;\n" - "}\n"; + mInterfaceCreateAlgebraicVariablesArrayMethodString = "double * createAlgebraicVariablesArray();\n"; + mImplementationCreateAlgebraicVariablesArrayMethodString = "double * createAlgebraicVariablesArray()\n" + "{\n" + " double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double));\n" + "\n" + " for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) {\n" + " res[i] = NAN;\n" + " }\n" + "\n" + " return res;\n" + "}\n"; + + mInterfaceCreateExternalVariablesArrayMethodString = "double * createExternalVariablesArray();\n"; + mImplementationCreateExternalVariablesArrayMethodString = "double * createExternalVariablesArray()\n" + "{\n" + " double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double));\n" + "\n" + " for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) {\n" + " res[i] = NAN;\n" + " }\n" + "\n" + " return res;\n" + "}\n"; mInterfaceDeleteArrayMethodString = "void deleteArray(double *array);\n"; mImplementationDeleteArrayMethodString = "void deleteArray(double *array)\n" @@ -477,14 +477,14 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " free(array);\n" "}\n"; - mInterfaceInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *computedConstants, double *algebraic);\n"; - mImplementationInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *computedConstants, double *algebraic)\n" + mInterfaceInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables);\n"; + mImplementationInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" "[CODE]" "}\n"; - mInterfaceInitialiseVariablesMethodFdmString = "void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n"; - mImplementationInitialiseVariablesMethodFdmString = "void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + mInterfaceInitialiseVariablesMethodFdmString = "void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n"; + mImplementationInitialiseVariablesMethodFdmString = "void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" "[CODE]" "}\n"; @@ -495,36 +495,36 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "}\n"; - mInterfaceComputeRatesMethodWoevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n"; - mImplementationComputeRatesMethodWoevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n" + mInterfaceComputeRatesMethodWoevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n"; + mImplementationComputeRatesMethodWoevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n{\n" "[CODE]" "}\n"; - mInterfaceComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n"; - mImplementationComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n{\n" + mInterfaceComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable);\n"; + mImplementationComputeRatesMethodWevString = "void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable)\n{\n" "[CODE]" "}\n"; - mInterfaceComputeVariablesMethodFamWoevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic);\n"; - mImplementationComputeVariablesMethodFamWoevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic)\n" + mInterfaceComputeVariablesMethodFamWoevString = "void computeVariables(double *constants, double *computedConstants, double *algebraicVariables);\n"; + mImplementationComputeVariablesMethodFamWoevString = "void computeVariables(double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" "[CODE]" "}\n"; - mInterfaceComputeVariablesMethodFamWevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n"; - mImplementationComputeVariablesMethodFamWevString = "void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n" + mInterfaceComputeVariablesMethodFamWevString = "void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable);\n"; + mImplementationComputeVariablesMethodFamWevString = "void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n"; - mInterfaceComputeVariablesMethodFdmWoevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n"; - mImplementationComputeVariablesMethodFdmWoevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + mInterfaceComputeVariablesMethodFdmWoevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n"; + mImplementationComputeVariablesMethodFdmWoevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" "[CODE]" "}\n"; - mInterfaceComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n"; - mImplementationComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n" + mInterfaceComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable);\n"; + mImplementationComputeVariablesMethodFdmWevString = "void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n"; @@ -752,11 +752,11 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceComputedConstantCountString = ""; mImplementationComputedConstantCountString = "COMPUTED_CONSTANT_COUNT = [COMPUTED_CONSTANT_COUNT]\n"; - mInterfaceAlgebraicCountString = ""; - mImplementationAlgebraicCountString = "ALGEBRAIC_COUNT = [ALGEBRAIC_COUNT]\n"; + mInterfaceAlgebraicVariableCountString = ""; + mImplementationAlgebraicVariableCountString = "ALGEBRAIC_VARIABLE_COUNT = [ALGEBRAIC_VARIABLE_COUNT]\n"; - mInterfaceExternalCountString = ""; - mImplementationExternalCountString = "EXTERNAL_COUNT = [EXTERNAL_COUNT]\n"; + mInterfaceExternalVariableCountString = ""; + mImplementationExternalVariableCountString = "EXTERNAL_VARIABLE_COUNT = [EXTERNAL_VARIABLE_COUNT]\n"; mVariableInfoObjectString = ""; @@ -778,15 +778,15 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "]\n"; - mInterfaceAlgebraicInfoString = ""; - mImplementationAlgebraicInfoString = "ALGEBRAIC_INFO = [\n" - "[CODE]" - "]\n"; + mInterfaceAlgebraicVariableInfoString = ""; + mImplementationAlgebraicVariableInfoString = "ALGEBRAIC_INFO = [\n" + "[CODE]" + "]\n"; - mInterfaceExternalInfoString = ""; - mImplementationExternalInfoString = "EXTERNAL_INFO = [\n" - "[CODE]" - "]\n"; + mInterfaceExternalVariableInfoString = ""; + mImplementationExternalVariableInfoString = "EXTERNAL_INFO = [\n" + "[CODE]" + "]\n"; mVariableInfoEntryString = "{\"name\": \"[NAME]\", \"units\": \"[UNITS]\", \"component\": \"[COMPONENT]\"}"; @@ -796,14 +796,14 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mRatesArrayString = "rates"; mConstantsArrayString = "constants"; mComputedConstantsArrayString = "computed_constants"; - mAlgebraicArrayString = "algebraic"; - mExternalArrayString = "externals"; + mAlgebraicVariablesArrayString = "algebraicVariables"; + mExternalVariablesArrayString = "externalVariables"; mExternalVariableMethodTypeDefinitionFamString = ""; mExternalVariableMethodTypeDefinitionFdmString = ""; - mExternalVariableMethodCallFamString = "external_variable(constants, computed_constants, algebraic, externals, [INDEX])"; - mExternalVariableMethodCallFdmString = "external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, [INDEX])"; + mExternalVariableMethodCallFamString = "external_variable(constants, computed_constants, algebraic_variables, external_variables, [INDEX])"; + mExternalVariableMethodCallFdmString = "external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, [INDEX])"; mRootFindingInfoObjectFamWoevString = ""; mRootFindingInfoObjectFamWevString = ""; @@ -814,50 +814,50 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "from nlasolver import nla_solve" "\n"; - mFindRootCallFamWoevString = "find_root_[INDEX](constants, computed_constants, algebraic)\n"; - mFindRootCallFamWevString = "find_root_[INDEX](constants, computed_constants, algebraic, externals)\n"; - mFindRootCallFdmWoevString = "find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic)\n"; - mFindRootCallFdmWevString = "find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic, externals)\n"; + mFindRootCallFamWoevString = "find_root_[INDEX](constants, computed_constants, algebraic_variables)\n"; + mFindRootCallFamWevString = "find_root_[INDEX](constants, computed_constants, algebraic_variables, external_variables)\n"; + mFindRootCallFdmWoevString = "find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic_variables)\n"; + mFindRootCallFdmWevString = "find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic_variables, external_variables)\n"; mFindRootMethodFamWoevString = "\n" - "def find_root_[INDEX](constants, computed_constants, algebraic):\n" + "def find_root_[INDEX](constants, computed_constants, algebraic_variables):\n" " u = [nan]*[SIZE]\n" "\n" "[CODE]"; mFindRootMethodFamWevString = "\n" - "def find_root_[INDEX](constants, computed_constants, algebraic, externals):\n" + "def find_root_[INDEX](constants, computed_constants, algebraic_variables, external_variables):\n" " u = [nan]*[SIZE]\n" "\n" "[CODE]"; mFindRootMethodFdmWoevString = "\n" - "def find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic):\n" + "def find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic_variables):\n" " u = [nan]*[SIZE]\n" "\n" "[CODE]"; mFindRootMethodFdmWevString = "\n" - "def find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic, externals):\n" + "def find_root_[INDEX](voi, states, rates, constants, computed_constants, algebraic_variables, external_variables):\n" " u = [nan]*[SIZE]\n" "\n" "[CODE]"; - mNlaSolveCallFamWoevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [constants, computed_constants, algebraic])\n"; - mNlaSolveCallFamWevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [constants, computed_constants, algebraic, externals])\n"; - mNlaSolveCallFdmWoevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [voi, states, rates, constants, computed_constants, algebraic])\n"; - mNlaSolveCallFdmWevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [voi, states, rates, constants, computed_constants, algebraic, externals])\n"; + mNlaSolveCallFamWoevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [constants, computed_constants, algebraic_variables])\n"; + mNlaSolveCallFamWevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [constants, computed_constants, algebraic_variables, external_variables])\n"; + mNlaSolveCallFdmWoevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [voi, states, rates, constants, computed_constants, algebraic_variables])\n"; + mNlaSolveCallFdmWevString = "u = nla_solve(objective_function_[INDEX], u, [SIZE], [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables])\n"; mObjectiveFunctionMethodFamWoevString = "\n" "def objective_function_[INDEX](u, f, data):\n" " constants = data[0]\n" " computed_constants = data[1]\n" - " algebraic = data[2]\n" + " algebraic_variables = data[2]\n" "\n" "[CODE]"; mObjectiveFunctionMethodFamWevString = "\n" "def objective_function_[INDEX](u, f, data):\n" " constants = data[0]\n" " computed_constants = data[1]\n" - " algebraic = data[2]\n" - " externals = data[3]\n" + " algebraic_variables = data[2]\n" + " external_variables = data[3]\n" "\n" "[CODE]"; mObjectiveFunctionMethodFdmWoevString = "\n" @@ -867,7 +867,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " rates = data[2]\n" " constants = data[3]\n" " computed_constants = data[4]\n" - " algebraic = data[5]\n" + " algebraic_variables = data[5]\n" "\n" "[CODE]"; mObjectiveFunctionMethodFdmWevString = "\n" @@ -877,8 +877,8 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " rates = data[2]\n" " constants = data[3]\n" " computed_constants = data[4]\n" - " algebraic = data[5]\n" - " externals = data[6]\n" + " algebraic_variables = data[5]\n" + " external_variables = data[6]\n" "\n" "[CODE]"; @@ -900,27 +900,27 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "def create_computed_constants_array():\n" " return [nan]*COMPUTED_CONSTANT_COUNT\n"; - mInterfaceCreateAlgebraicArrayMethodString = ""; - mImplementationCreateAlgebraicArrayMethodString = "\n" - "def create_algebraic_array():\n" - " return [nan]*ALGEBRAIC_COUNT\n"; + mInterfaceCreateAlgebraicVariablesArrayMethodString = ""; + mImplementationCreateAlgebraicVariablesArrayMethodString = "\n" + "def create_algebraic_variables_array():\n" + " return [nan]*ALGEBRAIC_VARIABLE_COUNT\n"; - mInterfaceCreateExternalsArrayMethodString = ""; - mImplementationCreateExternalsArrayMethodString = "\n" - "def create_externals_array():\n" - " return [nan]*EXTERNAL_COUNT\n"; + mInterfaceCreateExternalVariablesArrayMethodString = ""; + mImplementationCreateExternalVariablesArrayMethodString = "\n" + "def create_external_variables_array():\n" + " return [nan]*EXTERNAL_VARIABLE_COUNT\n"; mInterfaceDeleteArrayMethodString = ""; mImplementationDeleteArrayMethodString = ""; mInterfaceInitialiseVariablesMethodFamString = ""; mImplementationInitialiseVariablesMethodFamString = "\n" - "def initialise_variables(constants, computed_constants, algebraic):\n" + "def initialise_variables(constants, computed_constants, algebraic_variables):\n" "[CODE]"; mInterfaceInitialiseVariablesMethodFdmString = ""; mImplementationInitialiseVariablesMethodFdmString = "\n" - "def initialise_variables(states, rates, constants, computed_constants, algebraic):\n" + "def initialise_variables(states, rates, constants, computed_constants, algebraic_variables):\n" "[CODE]"; mInterfaceComputeComputedConstantsMethodString = ""; @@ -930,32 +930,32 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceComputeRatesMethodWoevString = ""; mImplementationComputeRatesMethodWoevString = "\n" - "def compute_rates(voi, states, rates, constants, computed_constants, algebraic):\n" + "def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables):\n" "[CODE]"; mInterfaceComputeRatesMethodWevString = ""; mImplementationComputeRatesMethodWevString = "\n" - "def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable):\n" + "def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable):\n" "[CODE]"; mInterfaceComputeVariablesMethodFamWoevString = ""; mImplementationComputeVariablesMethodFamWoevString = "\n" - "def compute_variables(constants, computed_constants, algebraic):\n" + "def compute_variables(constants, computed_constants, algebraic_variables):\n" "[CODE]"; mInterfaceComputeVariablesMethodFamWevString = ""; mImplementationComputeVariablesMethodFamWevString = "\n" - "def compute_variables(constants, computed_constants, algebraic, externals, external_variable):\n" + "def compute_variables(constants, computed_constants, algebraic_variables, external_variables, external_variable):\n" "[CODE]"; mInterfaceComputeVariablesMethodFdmWoevString = ""; mImplementationComputeVariablesMethodFdmWoevString = "\n" - "def compute_variables(voi, states, rates, constants, computed_constants, algebraic):\n" + "def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables):\n" "[CODE]"; mInterfaceComputeVariablesMethodFdmWevString = ""; mImplementationComputeVariablesMethodFdmWevString = "\n" - "def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable):\n" + "def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable):\n" "[CODE]"; mEmptyMethodString = "pass\n"; @@ -2141,44 +2141,44 @@ void GeneratorProfile::setImplementationComputedConstantCountString(const std::s mPimpl->mImplementationComputedConstantCountString = implementationComputedConstantCountString; } -std::string GeneratorProfile::interfaceAlgebraicCountString() const +std::string GeneratorProfile::interfaceAlgebraicVariableCountString() const { - return mPimpl->mInterfaceAlgebraicCountString; + return mPimpl->mInterfaceAlgebraicVariableCountString; } -void GeneratorProfile::setInterfaceAlgebraicCountString(const std::string &interfaceAlgebraicCountString) +void GeneratorProfile::setInterfaceAlgebraicVariableCountString(const std::string &interfaceAlgebraicVariableCountString) { - mPimpl->mInterfaceAlgebraicCountString = interfaceAlgebraicCountString; + mPimpl->mInterfaceAlgebraicVariableCountString = interfaceAlgebraicVariableCountString; } -std::string GeneratorProfile::implementationAlgebraicCountString() const +std::string GeneratorProfile::implementationAlgebraicVariableCountString() const { - return mPimpl->mImplementationAlgebraicCountString; + return mPimpl->mImplementationAlgebraicVariableCountString; } -void GeneratorProfile::setImplementationAlgebraicCountString(const std::string &implementationAlgebraicCountString) +void GeneratorProfile::setImplementationAlgebraicVariableCountString(const std::string &implementationAlgebraicVariableCountString) { - mPimpl->mImplementationAlgebraicCountString = implementationAlgebraicCountString; + mPimpl->mImplementationAlgebraicVariableCountString = implementationAlgebraicVariableCountString; } -std::string GeneratorProfile::interfaceExternalCountString() const +std::string GeneratorProfile::interfaceExternalVariableCountString() const { - return mPimpl->mInterfaceExternalCountString; + return mPimpl->mInterfaceExternalVariableCountString; } -void GeneratorProfile::setInterfaceExternalCountString(const std::string &interfaceExternalCountString) +void GeneratorProfile::setInterfaceExternalVariableCountString(const std::string &interfaceExternalVariableCountString) { - mPimpl->mInterfaceExternalCountString = interfaceExternalCountString; + mPimpl->mInterfaceExternalVariableCountString = interfaceExternalVariableCountString; } -std::string GeneratorProfile::implementationExternalCountString() const +std::string GeneratorProfile::implementationExternalVariableCountString() const { - return mPimpl->mImplementationExternalCountString; + return mPimpl->mImplementationExternalVariableCountString; } -void GeneratorProfile::setImplementationExternalCountString(const std::string &implementationExternalCountString) +void GeneratorProfile::setImplementationExternalVariableCountString(const std::string &implementationExternalVariableCountString) { - mPimpl->mImplementationExternalCountString = implementationExternalCountString; + mPimpl->mImplementationExternalVariableCountString = implementationExternalVariableCountString; } std::string GeneratorProfile::variableInfoObjectString() const @@ -2271,44 +2271,44 @@ void GeneratorProfile::setImplementationComputedConstantInfoString(const std::st mPimpl->mImplementationComputedConstantInfoString = implementationComputedConstantInfoString; } -std::string GeneratorProfile::interfaceAlgebraicInfoString() const +std::string GeneratorProfile::interfaceAlgebraicVariableInfoString() const { - return mPimpl->mInterfaceAlgebraicInfoString; + return mPimpl->mInterfaceAlgebraicVariableInfoString; } -void GeneratorProfile::setInterfaceAlgebraicInfoString(const std::string &interfaceAlgebraicInfoString) +void GeneratorProfile::setInterfaceAlgebraicVariableInfoString(const std::string &interfaceAlgebraicVariableInfoString) { - mPimpl->mInterfaceAlgebraicInfoString = interfaceAlgebraicInfoString; + mPimpl->mInterfaceAlgebraicVariableInfoString = interfaceAlgebraicVariableInfoString; } -std::string GeneratorProfile::implementationAlgebraicInfoString() const +std::string GeneratorProfile::implementationAlgebraicVariableInfoString() const { - return mPimpl->mImplementationAlgebraicInfoString; + return mPimpl->mImplementationAlgebraicVariableInfoString; } -void GeneratorProfile::setImplementationAlgebraicInfoString(const std::string &implementationAlgebraicInfoString) +void GeneratorProfile::setImplementationAlgebraicVariableInfoString(const std::string &implementationAlgebraicVariableInfoString) { - mPimpl->mImplementationAlgebraicInfoString = implementationAlgebraicInfoString; + mPimpl->mImplementationAlgebraicVariableInfoString = implementationAlgebraicVariableInfoString; } -std::string GeneratorProfile::interfaceExternalInfoString() const +std::string GeneratorProfile::interfaceExternalVariableInfoString() const { - return mPimpl->mInterfaceExternalInfoString; + return mPimpl->mInterfaceExternalVariableInfoString; } -void GeneratorProfile::setInterfaceExternalInfoString(const std::string &interfaceExternalInfoString) +void GeneratorProfile::setInterfaceExternalVariableInfoString(const std::string &interfaceExternalVariableInfoString) { - mPimpl->mInterfaceExternalInfoString = interfaceExternalInfoString; + mPimpl->mInterfaceExternalVariableInfoString = interfaceExternalVariableInfoString; } -std::string GeneratorProfile::implementationExternalInfoString() const +std::string GeneratorProfile::implementationExternalVariableInfoString() const { - return mPimpl->mImplementationExternalInfoString; + return mPimpl->mImplementationExternalVariableInfoString; } -void GeneratorProfile::setImplementationExternalInfoString(const std::string &implementationExternalInfoString) +void GeneratorProfile::setImplementationExternalVariableInfoString(const std::string &implementationExternalVariableInfoString) { - mPimpl->mImplementationExternalInfoString = implementationExternalInfoString; + mPimpl->mImplementationExternalVariableInfoString = implementationExternalVariableInfoString; } std::string GeneratorProfile::variableInfoEntryString() const @@ -2371,24 +2371,24 @@ void GeneratorProfile::setComputedConstantsArrayString(const std::string &comput mPimpl->mComputedConstantsArrayString = computedConstantsArrayString; } -std::string GeneratorProfile::algebraicArrayString() const +std::string GeneratorProfile::algebraicVariablesArrayString() const { - return mPimpl->mAlgebraicArrayString; + return mPimpl->mAlgebraicVariablesArrayString; } -void GeneratorProfile::setAlgebraicArrayString(const std::string &algebraicArrayString) +void GeneratorProfile::setAlgebraicVariablesArrayString(const std::string &algebraicVariablesArrayString) { - mPimpl->mAlgebraicArrayString = algebraicArrayString; + mPimpl->mAlgebraicVariablesArrayString = algebraicVariablesArrayString; } -std::string GeneratorProfile::externalArrayString() const +std::string GeneratorProfile::externalVariablesArrayString() const { - return mPimpl->mExternalArrayString; + return mPimpl->mExternalVariablesArrayString; } -void GeneratorProfile::setExternalArrayString(const std::string &externalArrayString) +void GeneratorProfile::setExternalVariablesArrayString(const std::string &externalVariablesArrayString) { - mPimpl->mExternalArrayString = externalArrayString; + mPimpl->mExternalVariablesArrayString = externalVariablesArrayString; } std::string GeneratorProfile::externalVariableMethodTypeDefinitionString(bool forDifferentialModel) const @@ -2704,44 +2704,44 @@ void GeneratorProfile::setImplementationCreateComputedConstantsArrayMethodString mPimpl->mImplementationCreateComputedConstantsArrayMethodString = implementationCreateComputedConstantsArrayMethodString; } -std::string GeneratorProfile::interfaceCreateAlgebraicArrayMethodString() const +std::string GeneratorProfile::interfaceCreateAlgebraicVariablesArrayMethodString() const { - return mPimpl->mInterfaceCreateAlgebraicArrayMethodString; + return mPimpl->mInterfaceCreateAlgebraicVariablesArrayMethodString; } -void GeneratorProfile::setInterfaceCreateAlgebraicArrayMethodString(const std::string &interfaceCreateAlgebraicArrayMethodString) +void GeneratorProfile::setInterfaceCreateAlgebraicVariablesArrayMethodString(const std::string &interfaceCreateAlgebraicVariablesArrayMethodString) { - mPimpl->mInterfaceCreateAlgebraicArrayMethodString = interfaceCreateAlgebraicArrayMethodString; + mPimpl->mInterfaceCreateAlgebraicVariablesArrayMethodString = interfaceCreateAlgebraicVariablesArrayMethodString; } -std::string GeneratorProfile::implementationCreateAlgebraicArrayMethodString() const +std::string GeneratorProfile::implementationCreateAlgebraicVariablesArrayMethodString() const { - return mPimpl->mImplementationCreateAlgebraicArrayMethodString; + return mPimpl->mImplementationCreateAlgebraicVariablesArrayMethodString; } -void GeneratorProfile::setImplementationCreateAlgebraicArrayMethodString(const std::string &implementationCreateAlgebraicArrayMethodString) +void GeneratorProfile::setImplementationCreateAlgebraicVariablesArrayMethodString(const std::string &implementationCreateAlgebraicVariablesArrayMethodString) { - mPimpl->mImplementationCreateAlgebraicArrayMethodString = implementationCreateAlgebraicArrayMethodString; + mPimpl->mImplementationCreateAlgebraicVariablesArrayMethodString = implementationCreateAlgebraicVariablesArrayMethodString; } -std::string GeneratorProfile::interfaceCreateExternalsArrayMethodString() const +std::string GeneratorProfile::interfaceCreateExternalVariablesArrayMethodString() const { - return mPimpl->mInterfaceCreateExternalsArrayMethodString; + return mPimpl->mInterfaceCreateExternalVariablesArrayMethodString; } -void GeneratorProfile::setInterfaceCreateExternalsArrayMethodString(const std::string &interfaceCreateExternalsArrayMethodString) +void GeneratorProfile::setInterfaceCreateExternalVariablesArrayMethodString(const std::string &interfaceCreateExternalVariablesArrayMethodString) { - mPimpl->mInterfaceCreateExternalsArrayMethodString = interfaceCreateExternalsArrayMethodString; + mPimpl->mInterfaceCreateExternalVariablesArrayMethodString = interfaceCreateExternalVariablesArrayMethodString; } -std::string GeneratorProfile::implementationCreateExternalsArrayMethodString() const +std::string GeneratorProfile::implementationCreateExternalVariablesArrayMethodString() const { - return mPimpl->mImplementationCreateExternalsArrayMethodString; + return mPimpl->mImplementationCreateExternalVariablesArrayMethodString; } -void GeneratorProfile::setImplementationCreateExternalsArrayMethodString(const std::string &implementationCreateExternalsArrayMethodString) +void GeneratorProfile::setImplementationCreateExternalVariablesArrayMethodString(const std::string &implementationCreateExternalVariablesArrayMethodString) { - mPimpl->mImplementationCreateExternalsArrayMethodString = implementationCreateExternalsArrayMethodString; + mPimpl->mImplementationCreateExternalVariablesArrayMethodString = implementationCreateExternalVariablesArrayMethodString; } std::string GeneratorProfile::interfaceDeleteArrayMethodString() const diff --git a/src/generatorprofile_p.h b/src/generatorprofile_p.h index 0a44b83d0..f27bdee89 100644 --- a/src/generatorprofile_p.h +++ b/src/generatorprofile_p.h @@ -182,11 +182,11 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mInterfaceComputedConstantCountString; std::string mImplementationComputedConstantCountString; - std::string mInterfaceAlgebraicCountString; - std::string mImplementationAlgebraicCountString; + std::string mInterfaceAlgebraicVariableCountString; + std::string mImplementationAlgebraicVariableCountString; - std::string mInterfaceExternalCountString; - std::string mImplementationExternalCountString; + std::string mInterfaceExternalVariableCountString; + std::string mImplementationExternalVariableCountString; std::string mVariableInfoObjectString; @@ -202,11 +202,11 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mInterfaceComputedConstantInfoString; std::string mImplementationComputedConstantInfoString; - std::string mInterfaceAlgebraicInfoString; - std::string mImplementationAlgebraicInfoString; + std::string mInterfaceAlgebraicVariableInfoString; + std::string mImplementationAlgebraicVariableInfoString; - std::string mInterfaceExternalInfoString; - std::string mImplementationExternalInfoString; + std::string mInterfaceExternalVariableInfoString; + std::string mImplementationExternalVariableInfoString; std::string mVariableInfoEntryString; @@ -216,8 +216,8 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mRatesArrayString; std::string mConstantsArrayString; std::string mComputedConstantsArrayString; - std::string mAlgebraicArrayString; - std::string mExternalArrayString; + std::string mAlgebraicVariablesArrayString; + std::string mExternalVariablesArrayString; std::string mExternalVariableMethodTypeDefinitionFamString; std::string mExternalVariableMethodTypeDefinitionFdmString; @@ -264,11 +264,11 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mInterfaceCreateComputedConstantsArrayMethodString; std::string mImplementationCreateComputedConstantsArrayMethodString; - std::string mInterfaceCreateAlgebraicArrayMethodString; - std::string mImplementationCreateAlgebraicArrayMethodString; + std::string mInterfaceCreateAlgebraicVariablesArrayMethodString; + std::string mImplementationCreateAlgebraicVariablesArrayMethodString; - std::string mInterfaceCreateExternalsArrayMethodString; - std::string mImplementationCreateExternalsArrayMethodString; + std::string mInterfaceCreateExternalVariablesArrayMethodString; + std::string mImplementationCreateExternalVariablesArrayMethodString; std::string mInterfaceDeleteArrayMethodString; std::string mImplementationDeleteArrayMethodString; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 1bb721da2..81570372b 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "f0d3add475025d2d4b805747828dbaf2f1345b2f"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "35838d23a1b89fe47293f75e2684ba6d230cf4a8"; +static const char C_GENERATOR_PROFILE_SHA1[] = "35703a49bbac407bd614743267eafea5ca1310ef"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "68c4de7463e2319e5626d83d71b1d1dc34c446b7"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index 9b4d0086d..81937a821 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -448,11 +448,11 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->interfaceComputedConstantCountString() + generatorProfile->implementationComputedConstantCountString(); - profileContents += generatorProfile->interfaceAlgebraicCountString() - + generatorProfile->implementationAlgebraicCountString(); + profileContents += generatorProfile->interfaceAlgebraicVariableCountString() + + generatorProfile->implementationAlgebraicVariableCountString(); - profileContents += generatorProfile->interfaceExternalCountString() - + generatorProfile->implementationExternalCountString(); + profileContents += generatorProfile->interfaceExternalVariableCountString() + + generatorProfile->implementationExternalVariableCountString(); profileContents += generatorProfile->variableInfoObjectString(); @@ -468,11 +468,11 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->interfaceComputedConstantInfoString() + generatorProfile->implementationComputedConstantInfoString(); - profileContents += generatorProfile->interfaceAlgebraicInfoString() - + generatorProfile->implementationAlgebraicInfoString(); + profileContents += generatorProfile->interfaceAlgebraicVariableInfoString() + + generatorProfile->implementationAlgebraicVariableInfoString(); - profileContents += generatorProfile->interfaceExternalInfoString() - + generatorProfile->implementationExternalInfoString(); + profileContents += generatorProfile->interfaceExternalVariableInfoString() + + generatorProfile->implementationExternalVariableInfoString(); profileContents += generatorProfile->variableInfoEntryString(); @@ -482,8 +482,8 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile + generatorProfile->ratesArrayString() + generatorProfile->constantsArrayString() + generatorProfile->computedConstantsArrayString() - + generatorProfile->algebraicArrayString() - + generatorProfile->externalArrayString(); + + generatorProfile->algebraicVariablesArrayString() + + generatorProfile->externalVariablesArrayString(); profileContents += generatorProfile->externalVariableMethodTypeDefinitionString(false) + generatorProfile->externalVariableMethodTypeDefinitionString(true); @@ -524,11 +524,11 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->interfaceCreateComputedConstantsArrayMethodString() + generatorProfile->implementationCreateComputedConstantsArrayMethodString(); - profileContents += generatorProfile->interfaceCreateAlgebraicArrayMethodString() - + generatorProfile->implementationCreateAlgebraicArrayMethodString(); + profileContents += generatorProfile->interfaceCreateAlgebraicVariablesArrayMethodString() + + generatorProfile->implementationCreateAlgebraicVariablesArrayMethodString(); - profileContents += generatorProfile->interfaceCreateExternalsArrayMethodString() - + generatorProfile->implementationCreateExternalsArrayMethodString(); + profileContents += generatorProfile->interfaceCreateExternalVariablesArrayMethodString() + + generatorProfile->implementationCreateExternalVariablesArrayMethodString(); profileContents += generatorProfile->interfaceDeleteArrayMethodString() + generatorProfile->implementationDeleteArrayMethodString(); diff --git a/src/issue.cpp b/src/issue.cpp index 6d43d195d..38086af46 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -208,7 +208,7 @@ static const std::map> ruleToInfo {Issue::ReferenceRule::ANALYSER_ODE_NOT_FIRST_ORDER, {"ANALYSER_ODE_NOT_FIRST_ORDER", "", docsUrl, ""}}, {Issue::ReferenceRule::ANALYSER_VARIABLE_UNUSED, {"ANALYSER_VARIABLE_UNUSED", "", docsUrl, ""}}, {Issue::ReferenceRule::ANALYSER_STATE_NOT_INITIALISED, {"ANALYSER_STATE_NOT_INITIALISED", "", docsUrl, ""}}, - {Issue::ReferenceRule::ANALYSER_STATE_RATE_AS_ALGEBRAIC, {"ANALYSER_STATE_RATE_AS_ALGEBRAIC", "", docsUrl, ""}}, + {Issue::ReferenceRule::ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE, {"ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE", "", docsUrl, ""}}, {Issue::ReferenceRule::ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE, {"ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE", "", docsUrl, ""}}, {Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_DIFFERENT_MODEL, {"ANALYSER_EXTERNAL_VARIABLE_DIFFERENT_MODEL", "", docsUrl, ""}}, {Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_VOI, {"ANALYSER_EXTERNAL_VARIABLE_VOI", "", docsUrl, ""}}, diff --git a/src/utilities.cpp b/src/utilities.cpp index 996fc653f..a7eaf0430 100644 --- a/src/utilities.cpp +++ b/src/utilities.cpp @@ -1328,14 +1328,14 @@ std::vector variables(const AnalyserModelPtr &model) auto states = model->states(); auto constants = model->constants(); auto computedConstants = model->computedConstants(); - auto algebraic = model->algebraic(); - auto externals = model->externals(); + auto algebraicVariables = model->algebraicVariables(); + auto externalVariables = model->externalVariables(); res.insert(res.end(), states.begin(), states.end()); res.insert(res.end(), constants.begin(), constants.end()); res.insert(res.end(), computedConstants.begin(), computedConstants.end()); - res.insert(res.end(), algebraic.begin(), algebraic.end()); - res.insert(res.end(), externals.begin(), externals.end()); + res.insert(res.end(), algebraicVariables.begin(), algebraicVariables.end()); + res.insert(res.end(), externalVariables.begin(), externalVariables.end()); return res; } @@ -1344,12 +1344,12 @@ std::vector variables(const AnalyserEquationPtr &equation) { auto res = equation->states(); auto computedConstants = equation->computedConstants(); - auto algebraic = equation->algebraic(); - auto externals = equation->externals(); + auto algebraicVariables = equation->algebraicVariables(); + auto externalVariables = equation->externalVariables(); res.insert(res.end(), computedConstants.begin(), computedConstants.end()); - res.insert(res.end(), algebraic.begin(), algebraic.end()); - res.insert(res.end(), externals.begin(), externals.end()); + res.insert(res.end(), algebraicVariables.begin(), algebraicVariables.end()); + res.insert(res.end(), externalVariables.begin(), externalVariables.end()); return res; } diff --git a/tests/bindings/javascript/analyserequation.test.js b/tests/bindings/javascript/analyserequation.test.js index 826926899..09fb14cde 100644 --- a/tests/bindings/javascript/analyserequation.test.js +++ b/tests/bindings/javascript/analyserequation.test.js @@ -79,8 +79,8 @@ describe("Analyser Equation tests", () => { test('Checking Analyser Equation computedConstant.', () => { expect(eqn.computedConstant(0)).toBeNull() }); - test('Checking Analyser Equation algebraicCount.', () => { - expect(eqn.algebraicCount()).toBe(0) + test('Checking Analyser Equation algebraicVariableCount.', () => { + expect(eqn.algebraicVariableCount()).toBe(0) }); test('Checking Analyser Equation algebraicVariables.', () => { expect(eqn.algebraicVariables().size()).toBe(0) @@ -88,14 +88,14 @@ describe("Analyser Equation tests", () => { test('Checking Analyser Equation algebraicVariable.', () => { expect(eqn.algebraicVariable(0)).toBeNull() }); - test('Checking Analyser Equation externalCount.', () => { - expect(eqn.externalCount()).toBe(0) + test('Checking Analyser Equation externalVariableCount.', () => { + expect(eqn.externalVariableCount()).toBe(0) }); - test('Checking Analyser Equation externals.', () => { - expect(eqn.externals().size()).toBe(0) + test('Checking Analyser Equation externalVariables.', () => { + expect(eqn.externalVariables().size()).toBe(0) }); - test('Checking Analyser Equation external.', () => { - expect(eqn.external(0)).toBeNull() + test('Checking Analyser Equation externalVariable.', () => { + expect(eqn.externalVariable(0)).toBeNull() }); test('Checking Analyser Equation AST.', () => { expect(eqn.ast().value()).toBe("") diff --git a/tests/bindings/javascript/analysermodel.test.js b/tests/bindings/javascript/analysermodel.test.js index 3fe868c7a..e53830cc2 100644 --- a/tests/bindings/javascript/analysermodel.test.js +++ b/tests/bindings/javascript/analysermodel.test.js @@ -72,14 +72,14 @@ describe("Analyser Model tests", () => { expect(am.computedConstant(2).variable().name()).toBe("E_K") }); test('Checking Analyser Model algebraic variables related API.', () => { - expect(am.algebraicCount()).toBe(10) + expect(am.algebraicVariableCount()).toBe(10) expect(am.algebraicVariables().size()).toBe(10) expect(am.algebraicVariable(2).variable().name()).toBe("i_K") }); test('Checking Analyser Model external variables related API.', () => { - expect(am.externalCount()).toBe(0) - expect(am.externals().size()).toBe(0) - expect(am.external(0)).toBeNull() + expect(am.externalVariableCount()).toBe(0) + expect(am.externalVariables().size()).toBe(0) + expect(am.externalVariable(0)).toBeNull() }); test('Checking Analyser Model need* API.', () => { expect(am.needEqFunction()).toBe(false) diff --git a/tests/bindings/javascript/analyservariable.test.js b/tests/bindings/javascript/analyservariable.test.js index aa9cbb501..4e0130c6e 100644 --- a/tests/bindings/javascript/analyservariable.test.js +++ b/tests/bindings/javascript/analyservariable.test.js @@ -39,13 +39,13 @@ describe("Analyser Variable tests", () => { expect(am.constantCount()).toBe(5) expect(am.computedConstantCount()).toBe(3) - expect(am.algebraicCount()).toBe(10) - expect(am.externalCount()).toBe(0) + expect(am.algebraicVariableCount()).toBe(10) + expect(am.externalVariableCount()).toBe(0) }); test('Checking Analyser Variable type.', () => { const av = am.algebraicVariable(0) - expect(av.type().value).toBe(libcellml.AnalyserVariable.Type.ALGEBRAIC.value) - expect(libcellml.AnalyserVariable.typeAsString(av.type())).toBe("algebraic") + expect(av.type().value).toBe(libcellml.AnalyserVariable.Type.ALGEBRAIC_VARIABLE.value) + expect(libcellml.AnalyserVariable.typeAsString(av.type())).toBe("algebraic_variable") }); test('Checking Analyser Variable index.', () => { const av = am.algebraicVariable(7) diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index e3c40bfe4..0686dab2a 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -708,29 +708,29 @@ describe("GeneratorProfile tests", () => { x.setImplementationComputedConstantCountString("something") expect(x.implementationComputedConstantCountString()).toBe("something") }); - test("Checking GeneratorProfile.interfaceAlgebraicCountString.", () => { + test("Checking GeneratorProfile.interfaceAlgebraicVariableCountString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceAlgebraicCountString("something") - expect(x.interfaceAlgebraicCountString()).toBe("something") + x.setInterfaceAlgebraicVariableCountString("something") + expect(x.interfaceAlgebraicVariableCountString()).toBe("something") }); - test("Checking GeneratorProfile.implementationAlgebraicCountString.", () => { + test("Checking GeneratorProfile.implementationAlgebraicVariableCountString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationAlgebraicCountString("something") - expect(x.implementationAlgebraicCountString()).toBe("something") + x.setImplementationAlgebraicVariableCountString("something") + expect(x.implementationAlgebraicVariableCountString()).toBe("something") }); - test("Checking GeneratorProfile.interfaceExternalCountString.", () => { + test("Checking GeneratorProfile.interfaceExternalVariableCountString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceExternalCountString("something") - expect(x.interfaceExternalCountString()).toBe("something") + x.setInterfaceExternalVariableCountString("something") + expect(x.interfaceExternalVariableCountString()).toBe("something") }); - test("Checking GeneratorProfile.implementationExternalCountString.", () => { + test("Checking GeneratorProfile.implementationExternalVariableCountString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationExternalCountString("something") - expect(x.implementationExternalCountString()).toBe("something") + x.setImplementationExternalVariableCountString("something") + expect(x.implementationExternalVariableCountString()).toBe("something") }); test("Checking GeneratorProfile.variableInfoObjectString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) @@ -786,29 +786,29 @@ describe("GeneratorProfile tests", () => { x.setImplementationComputedConstantInfoString("something") expect(x.implementationComputedConstantInfoString()).toBe("something") }); - test("Checking GeneratorProfile.interfaceAlgebraicInfoString.", () => { + test("Checking GeneratorProfile.interfaceAlgebraicVariableInfoString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceAlgebraicInfoString("something") - expect(x.interfaceAlgebraicInfoString()).toBe("something") + x.setInterfaceAlgebraicVariableInfoString("something") + expect(x.interfaceAlgebraicVariableInfoString()).toBe("something") }); - test("Checking GeneratorProfile.implementationAlgebraicInfoString.", () => { + test("Checking GeneratorProfile.implementationAlgebraicVariableInfoString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationAlgebraicInfoString("something") - expect(x.implementationAlgebraicInfoString()).toBe("something") + x.setImplementationAlgebraicVariableInfoString("something") + expect(x.implementationAlgebraicVariableInfoString()).toBe("something") }); - test("Checking GeneratorProfile.interfaceExternalInfoString.", () => { + test("Checking GeneratorProfile.interfaceExternalVariableInfoString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceExternalInfoString("something") - expect(x.interfaceExternalInfoString()).toBe("something") + x.setInterfaceExternalVariableInfoString("something") + expect(x.interfaceExternalVariableInfoString()).toBe("something") }); - test("Checking GeneratorProfile.implementationExternalInfoString.", () => { + test("Checking GeneratorProfile.implementationExternalVariableInfoString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationExternalInfoString("something") - expect(x.implementationExternalInfoString()).toBe("something") + x.setImplementationExternalVariableInfoString("something") + expect(x.implementationExternalVariableInfoString()).toBe("something") }); test("Checking GeneratorProfile.variableInfoEntryString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) @@ -939,17 +939,17 @@ describe("GeneratorProfile tests", () => { x.setComputedConstantsArrayString("something") expect(x.computedConstantsArrayString()).toBe("something") }); - test("Checking GeneratorProfile.algebraicArrayString.", () => { + test("Checking GeneratorProfile.algebraicVariablesArrayString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setAlgebraicArrayString("something") - expect(x.algebraicArrayString()).toBe("something") + x.setAlgebraicVariablesArrayString("something") + expect(x.algebraicVariablesArrayString()).toBe("something") }); - test("Checking GeneratorProfile.externalArrayString.", () => { + test("Checking GeneratorProfile.externalVariablesArrayString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setExternalArrayString("something") - expect(x.externalArrayString()).toBe("something") + x.setExternalVariablesArrayString("something") + expect(x.externalVariablesArrayString()).toBe("something") }); test("Checking GeneratorProfile.externalVariableMethodTypeDefinitionString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) @@ -1005,29 +1005,29 @@ describe("GeneratorProfile tests", () => { x.setImplementationCreateComputedConstantsArrayMethodString("something") expect(x.implementationCreateComputedConstantsArrayMethodString()).toBe("something") }); - test("Checking GeneratorProfile.interfaceCreateAlgebraicArrayMethodString.", () => { + test("Checking GeneratorProfile.interfaceCreateAlgebraicVariablesArrayMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceCreateAlgebraicArrayMethodString("something") - expect(x.interfaceCreateAlgebraicArrayMethodString()).toBe("something") + x.setInterfaceCreateAlgebraicVariablesArrayMethodString("something") + expect(x.interfaceCreateAlgebraicVariablesArrayMethodString()).toBe("something") }); - test("Checking GeneratorProfile.implementationCreateAlgebraicArrayMethodString.", () => { + test("Checking GeneratorProfile.implementationCreateAlgebraicVariablesArrayMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationCreateAlgebraicArrayMethodString("something") - expect(x.implementationCreateAlgebraicArrayMethodString()).toBe("something") + x.setImplementationCreateAlgebraicVariablesArrayMethodString("something") + expect(x.implementationCreateAlgebraicVariablesArrayMethodString()).toBe("something") }); - test("Checking GeneratorProfile.interfaceCreateExternalsArrayMethodString.", () => { + test("Checking GeneratorProfile.interfaceCreateExternalVariablesArrayMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceCreateExternalsArrayMethodString("something") - expect(x.interfaceCreateExternalsArrayMethodString()).toBe("something") + x.setInterfaceCreateExternalVariablesArrayMethodString("something") + expect(x.interfaceCreateExternalVariablesArrayMethodString()).toBe("something") }); - test("Checking GeneratorProfile.implementationCreateExternalsArrayMethodString.", () => { + test("Checking GeneratorProfile.implementationCreateExternalVariablesArrayMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationCreateExternalsArrayMethodString("something") - expect(x.implementationCreateExternalsArrayMethodString()).toBe("something") + x.setImplementationCreateExternalVariablesArrayMethodString("something") + expect(x.implementationCreateExternalVariablesArrayMethodString()).toBe("something") }); test("Checking GeneratorProfile.interfaceDeleteArrayMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/python/test_analyser.py b/tests/bindings/python/test_analyser.py index bcfc9bc2e..6f0244701 100644 --- a/tests/bindings/python/test_analyser.py +++ b/tests/bindings/python/test_analyser.py @@ -121,9 +121,9 @@ def test_coverage(self): self.assertEqual(0, am.computedConstantCount()) self.assertIsNotNone(am.computedConstants()) self.assertIsNone(am.computedConstant(3)) - self.assertEqual(12, am.algebraicCount()) - self.assertIsNotNone(am.algebraic()) - self.assertIsNotNone(am.algebraic(3)) + self.assertEqual(12, am.algebraicVariableCount()) + self.assertIsNotNone(am.algebraicVariables()) + self.assertIsNotNone(am.algebraicVariable(3)) self.assertEqual(16, am.equationCount()) self.assertIsNotNone(am.equations()) @@ -158,11 +158,11 @@ def test_coverage(self): # Ensure coverage for AnalyserVariable. - av = am.algebraic(3) + av = am.algebraicVariable(3) - self.assertEqual(AnalyserVariable.Type.ALGEBRAIC, av.type()) - self.assertEqual("algebraic", AnalyserVariable.typeAsString(av.type())) - self.assertEqual("algebraic", AnalyserVariable_typeAsString(av.type())) + self.assertEqual(AnalyserVariable.Type.ALGEBRAIC_VARIABLE, av.type()) + self.assertEqual("algebraic_variable", AnalyserVariable.typeAsString(av.type())) + self.assertEqual("algebraic_variable", AnalyserVariable_typeAsString(av.type())) self.assertEqual(3, av.index()) self.assertIsNone(av.initialisingVariable()) self.assertIsNotNone(av.variable()) @@ -189,12 +189,12 @@ def test_coverage(self): self.assertEqual(0, ae.computedConstantCount()) self.assertIsNotNone(ae.computedConstants()) self.assertIsNone(ae.computedConstant(0)) - self.assertEqual(1, ae.algebraicCount()) - self.assertIsNotNone(ae.algebraic()) - self.assertIsNotNone(ae.algebraic(0)) - self.assertEqual(0, ae.externalCount()) - self.assertIsNotNone(ae.externals()) - self.assertIsNone(ae.external(0)) + self.assertEqual(1, ae.algebraicVariableCount()) + self.assertIsNotNone(ae.algebraicVariables()) + self.assertIsNotNone(ae.algebraicVariable(0)) + self.assertEqual(0, ae.externalVariableCount()) + self.assertIsNotNone(ae.externalVariables()) + self.assertIsNone(ae.externalVariable(0)) # Check Analyser Equation type with invalid values. diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index 54befa012..a564c4711 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -718,13 +718,13 @@ def test_implementation_compute_rates_method_string(self): g = GeneratorProfile() self.assertEqual( - 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', + 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n{\n[CODE]}\n', g.implementationComputeRatesMethodString(False)) g.setImplementationComputeRatesMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeRatesMethodString(False)) self.assertEqual( - 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n{\n[CODE]}\n', + 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationComputeRatesMethodString(True)) g.setImplementationComputeRatesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeRatesMethodString(True)) @@ -735,25 +735,25 @@ def test_implementation_compute_variables_method_string(self): g = GeneratorProfile() self.assertEqual( - 'void computeVariables(double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', + 'void computeVariables(double *constants, double *computedConstants, double *algebraicVariables)\n{\n[CODE]}\n', g.implementationComputeVariablesMethodString(False, False)) g.setImplementationComputeVariablesMethodString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(False, False)) self.assertEqual( - 'void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n{\n[CODE]}\n', + 'void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationComputeVariablesMethodString(False, True)) g.setImplementationComputeVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(False, True)) self.assertEqual( - 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', + 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n{\n[CODE]}\n', g.implementationComputeVariablesMethodString(True, False)) g.setImplementationComputeVariablesMethodString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(True, False)) self.assertEqual( - 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n{\n[CODE]}\n', + 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable)\n{\n[CODE]}\n', g.implementationComputeVariablesMethodString(True, True)) g.setImplementationComputeVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeVariablesMethodString(True, True)) @@ -791,16 +791,16 @@ def test_implementation_create_computed_constants_array_method_string(self): g.setImplementationCreateComputedConstantsArrayMethodString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationCreateComputedConstantsArrayMethodString()) - def test_implementation_create_algebraic_array_method_string(self): + def test_implementation_create_algebraic_variables_array_method_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() self.assertEqual( - 'double * createAlgebraicArray()\n{\n double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double));\n\n for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) {\n res[i] = NAN;\n }\n\n return res;\n}\n', - g.implementationCreateAlgebraicArrayMethodString()) - g.setImplementationCreateAlgebraicArrayMethodString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationCreateAlgebraicArrayMethodString()) + 'double * createAlgebraicVariablesArray()\n{\n double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double));\n\n for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) {\n res[i] = NAN;\n }\n\n return res;\n}\n', + g.implementationCreateAlgebraicVariablesArrayMethodString()) + g.setImplementationCreateAlgebraicVariablesArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationCreateAlgebraicVariablesArrayMethodString()) def test_implementation_create_externals_array_method_string(self): from libcellml import GeneratorProfile @@ -808,10 +808,10 @@ def test_implementation_create_externals_array_method_string(self): g = GeneratorProfile() self.assertEqual( - 'double * createExternalsArray()\n{\n double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double));\n\n for (size_t i = 0; i < EXTERNAL_COUNT; ++i) {\n res[i] = NAN;\n }\n\n return res;\n}\n', - g.implementationCreateExternalsArrayMethodString()) - g.setImplementationCreateExternalsArrayMethodString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationCreateExternalsArrayMethodString()) + 'double * createExternalVariablesArray()\n{\n double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double));\n\n for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) {\n res[i] = NAN;\n }\n\n return res;\n}\n', + g.implementationCreateExternalVariablesArrayMethodString()) + g.setImplementationCreateExternalVariablesArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationCreateExternalVariablesArrayMethodString()) def test_implementation_delete_array_method_string(self): from libcellml import GeneratorProfile @@ -838,12 +838,12 @@ def test_implementation_initialise_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void initialiseVariables(double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(False)) g.setImplementationInitialiseVariablesMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(False)) - self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', + self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n{\n[CODE]}\n', g.implementationInitialiseVariablesMethodString(True)) g.setImplementationInitialiseVariablesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(True)) @@ -899,18 +899,18 @@ def test_implementation_algebraic_info_string(self): g = GeneratorProfile() - self.assertEqual('const VariableInfo ALGEBRAIC_INFO[] = {\n[CODE]};\n', g.implementationAlgebraicInfoString()) - g.setImplementationAlgebraicInfoString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationAlgebraicInfoString()) + self.assertEqual('const VariableInfo ALGEBRAIC_INFO[] = {\n[CODE]};\n', g.implementationAlgebraicVariableInfoString()) + g.setImplementationAlgebraicVariableInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationAlgebraicVariableInfoString()) def test_implementation_external_info_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('const VariableInfo EXTERNAL_INFO[] = {\n[CODE]};\n', g.implementationExternalInfoString()) - g.setImplementationExternalInfoString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationExternalInfoString()) + self.assertEqual('const VariableInfo EXTERNAL_INFO[] = {\n[CODE]};\n', g.implementationExternalVariableInfoString()) + g.setImplementationExternalVariableInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationExternalVariableInfoString()) def test_implementation_constant_count_string(self): from libcellml import GeneratorProfile @@ -930,23 +930,23 @@ def test_implementation_computed_constant_count_string(self): g.setImplementationComputedConstantCountString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputedConstantCountString()) - def test_implementation_algebraic_count_string(self): + def test_implementation_algebraic_variable_count_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('const size_t ALGEBRAIC_COUNT = [ALGEBRAIC_COUNT];\n', g.implementationAlgebraicCountString()) - g.setImplementationAlgebraicCountString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationAlgebraicCountString()) + self.assertEqual('const size_t ALGEBRAIC_VARIABLE_COUNT = [ALGEBRAIC_VARIABLE_COUNT];\n', g.implementationAlgebraicVariableCountString()) + g.setImplementationAlgebraicVariableCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationAlgebraicVariableCountString()) - def test_implementation_external_count_string(self): + def test_implementation_external_variable_count_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('const size_t EXTERNAL_COUNT = [EXTERNAL_COUNT];\n', g.implementationExternalCountString()) - g.setImplementationExternalCountString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationExternalCountString()) + self.assertEqual('const size_t EXTERNAL_VARIABLE_COUNT = [EXTERNAL_VARIABLE_COUNT];\n', g.implementationExternalVariableCountString()) + g.setImplementationExternalVariableCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationExternalVariableCountString()) def test_implementation_version_string(self): from libcellml import GeneratorProfile @@ -1000,13 +1000,13 @@ def test_interface_compute_rates_method_string(self): g = GeneratorProfile() self.assertEqual( - 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n', + 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n', g.interfaceComputeRatesMethodString(False)) g.setInterfaceComputeRatesMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeRatesMethodString(False)) self.assertEqual( - 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n', + 'void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable);\n', g.interfaceComputeRatesMethodString(True)) g.setInterfaceComputeRatesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeRatesMethodString(True)) @@ -1017,25 +1017,25 @@ def test_interface_compute_variables_method_string(self): g = GeneratorProfile() self.assertEqual( - 'void computeVariables(double *constants, double *computedConstants, double *algebraic);\n', + 'void computeVariables(double *constants, double *computedConstants, double *algebraicVariables);\n', g.interfaceComputeVariablesMethodString(False, False)) g.setInterfaceComputeVariablesMethodString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(False, False)) self.assertEqual( - 'void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n', + 'void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable);\n', g.interfaceComputeVariablesMethodString(False, True)) g.setInterfaceComputeVariablesMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(False, True)) self.assertEqual( - 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n', + 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n', g.interfaceComputeVariablesMethodString(True, False)) g.setInterfaceComputeVariablesMethodString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(True, False)) self.assertEqual( - 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n', + 'void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable);\n', g.interfaceComputeVariablesMethodString(True, True)) g.setInterfaceComputeVariablesMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeVariablesMethodString(True, True)) @@ -1067,23 +1067,23 @@ def test_interface_create_computed_constants_array_method_string(self): g.setInterfaceCreateComputedConstantsArrayMethodString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceCreateComputedConstantsArrayMethodString()) - def test_interface_create_algebraic_array_method_string(self): + def test_interface_create_algebraic_variables_array_method_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('double * createAlgebraicArray();\n', g.interfaceCreateAlgebraicArrayMethodString()) - g.setInterfaceCreateAlgebraicArrayMethodString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceCreateAlgebraicArrayMethodString()) + self.assertEqual('double * createAlgebraicVariablesArray();\n', g.interfaceCreateAlgebraicVariablesArrayMethodString()) + g.setInterfaceCreateAlgebraicVariablesArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceCreateAlgebraicVariablesArrayMethodString()) def test_interface_create_externals_array_method_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('double * createExternalsArray();\n', g.interfaceCreateExternalsArrayMethodString()) - g.setInterfaceCreateExternalsArrayMethodString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceCreateExternalsArrayMethodString()) + self.assertEqual('double * createExternalVariablesArray();\n', g.interfaceCreateExternalVariablesArrayMethodString()) + g.setInterfaceCreateExternalVariablesArrayMethodString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceCreateExternalVariablesArrayMethodString()) def test_interface_delete_array_method_string(self): from libcellml import GeneratorProfile @@ -1117,12 +1117,12 @@ def test_interface_initialise_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void initialiseVariables(double *constants, double *computedConstants, double *algebraic);\n', + self.assertEqual('void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables);\n', g.interfaceInitialiseVariablesMethodString(False)) g.setInterfaceInitialiseVariablesMethodString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(False)) - self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n', + self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n', g.interfaceInitialiseVariablesMethodString(True)) g.setInterfaceInitialiseVariablesMethodString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(True)) @@ -1177,18 +1177,18 @@ def test_interface_algebraic_info_string(self): g = GeneratorProfile() - self.assertEqual('extern const VariableInfo ALGEBRAIC_INFO[];\n', g.interfaceAlgebraicInfoString()) - g.setInterfaceAlgebraicInfoString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceAlgebraicInfoString()) + self.assertEqual('extern const VariableInfo ALGEBRAIC_INFO[];\n', g.interfaceAlgebraicVariableInfoString()) + g.setInterfaceAlgebraicVariableInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceAlgebraicVariableInfoString()) def test_interface_external_info_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('extern const VariableInfo EXTERNAL_INFO[];\n', g.interfaceExternalInfoString()) - g.setInterfaceExternalInfoString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceExternalInfoString()) + self.assertEqual('extern const VariableInfo EXTERNAL_INFO[];\n', g.interfaceExternalVariableInfoString()) + g.setInterfaceExternalVariableInfoString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceExternalVariableInfoString()) def test_interface_constant_count_string(self): from libcellml import GeneratorProfile @@ -1208,23 +1208,23 @@ def test_interface_computed_constant_count_string(self): g.setInterfaceComputedConstantCountString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputedConstantCountString()) - def test_interface_algebraic_count_string(self): + def test_interface_algebraic_variable_count_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('extern const size_t ALGEBRAIC_COUNT;\n', g.interfaceAlgebraicCountString()) - g.setInterfaceAlgebraicCountString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceAlgebraicCountString()) + self.assertEqual('extern const size_t ALGEBRAIC_VARIABLE_COUNT;\n', g.interfaceAlgebraicVariableCountString()) + g.setInterfaceAlgebraicVariableCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceAlgebraicVariableCountString()) - def test_interface_external_count_string(self): + def test_interface_external_variable_count_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('extern const size_t EXTERNAL_COUNT;\n', g.interfaceExternalCountString()) - g.setInterfaceExternalCountString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceExternalCountString()) + self.assertEqual('extern const size_t EXTERNAL_VARIABLE_COUNT;\n', g.interfaceExternalVariableCountString()) + g.setInterfaceExternalVariableCountString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceExternalVariableCountString()) def test_interface_version_string(self): from libcellml import GeneratorProfile @@ -1653,23 +1653,23 @@ def test_computed_constants_array_string(self): g.setComputedConstantsArrayString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.computedConstantsArrayString()) - def test_algebraic_array_string(self): + def test_algebraic_variables_array_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('algebraic', g.algebraicArrayString()) - g.setAlgebraicArrayString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.algebraicArrayString()) + self.assertEqual('algebraicVariables', g.algebraicVariablesArrayString()) + g.setAlgebraicVariablesArrayString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.algebraicVariablesArrayString()) - def test_external_array_string(self): + def test_external_variables_array_string(self): from libcellml import GeneratorProfile g = GeneratorProfile() - self.assertEqual('externals', g.externalArrayString()) - g.setExternalArrayString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalArrayString()) + self.assertEqual('externalVariables', g.externalVariablesArrayString()) + g.setExternalVariablesArrayString(GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariablesArrayString()) def test_external_variable_method_type_definition_string(self): from libcellml import GeneratorProfile @@ -1677,13 +1677,13 @@ def test_external_variable_method_type_definition_string(self): g = GeneratorProfile() self.assertEqual( - 'typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n', + 'typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index);\n', g.externalVariableMethodTypeDefinitionString(False)) g.setExternalVariableMethodTypeDefinitionString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodTypeDefinitionString(False)) self.assertEqual( - 'typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n', + 'typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index);\n', g.externalVariableMethodTypeDefinitionString(True)) g.setExternalVariableMethodTypeDefinitionString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodTypeDefinitionString(True)) @@ -1693,12 +1693,12 @@ def test_external_variable_method_call_string(self): g = GeneratorProfile() - self.assertEqual('externalVariable(constants, computedConstants, algebraic, externals, [INDEX])', + self.assertEqual('externalVariable(constants, computedConstants, algebraicVariables, externalVariables, [INDEX])', g.externalVariableMethodCallString(False)) g.setExternalVariableMethodCallString(False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodCallString(False)) - self.assertEqual('externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, [INDEX])', + self.assertEqual('externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, [INDEX])', g.externalVariableMethodCallString(True)) g.setExternalVariableMethodCallString(True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.externalVariableMethodCallString(True)) @@ -1708,19 +1708,19 @@ def test_root_finding_info_object_string(self): g = GeneratorProfile() - self.assertEqual('typedef struct {\n double *constants;\n double *computedConstants;\n double *algebraic;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(False, False)) + self.assertEqual('typedef struct {\n double *constants;\n double *computedConstants;\n double *algebraicVariables;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(False, False)) g.setRootFindingInfoObjectString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(False, False)) - self.assertEqual('typedef struct {\n double *constants;\n double *computedConstants;\n double *algebraic;\n double *externals;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(False, True)) + self.assertEqual('typedef struct {\n double *constants;\n double *computedConstants;\n double *algebraicVariables;\n double *externalVariables;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(False, True)) g.setRootFindingInfoObjectString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(False, True)) - self.assertEqual('typedef struct {\n double voi;\n double *states;\n double *rates;\n double *constants;\n double *computedConstants;\n double *algebraic;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(True, False)) + self.assertEqual('typedef struct {\n double voi;\n double *states;\n double *rates;\n double *constants;\n double *computedConstants;\n double *algebraicVariables;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(True, False)) g.setRootFindingInfoObjectString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(True, False)) - self.assertEqual('typedef struct {\n double voi;\n double *states;\n double *rates;\n double *constants;\n double *computedConstants;\n double *algebraic;\n double *externals;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(True, True)) + self.assertEqual('typedef struct {\n double voi;\n double *states;\n double *rates;\n double *constants;\n double *computedConstants;\n double *algebraicVariables;\n double *externalVariables;\n} RootFindingInfo;\n', g.rootFindingInfoObjectString(True, True)) g.setRootFindingInfoObjectString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.rootFindingInfoObjectString(True, True)) @@ -1738,19 +1738,19 @@ def test_find_root_call_string(self): g = GeneratorProfile() - self.assertEqual('findRoot[INDEX](constants, computedConstants, algebraic);\n', g.findRootCallString(False, False)) + self.assertEqual('findRoot[INDEX](constants, computedConstants, algebraicVariables);\n', g.findRootCallString(False, False)) g.setFindRootCallString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(False, False)) - self.assertEqual('findRoot[INDEX](constants, computedConstants, algebraic, externals);\n', g.findRootCallString(False, True)) + self.assertEqual('findRoot[INDEX](constants, computedConstants, algebraicVariables, externalVariables);\n', g.findRootCallString(False, True)) g.setFindRootCallString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(False, True)) - self.assertEqual('findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic);\n', g.findRootCallString(True, False)) + self.assertEqual('findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraicVariables);\n', g.findRootCallString(True, False)) g.setFindRootCallString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(True, False)) - self.assertEqual('findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic, externals);\n', g.findRootCallString(True, True)) + self.assertEqual('findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables);\n', g.findRootCallString(True, True)) g.setFindRootCallString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootCallString(True, True)) @@ -1759,19 +1759,19 @@ def test_find_root_method_string(self): g = GeneratorProfile() - self.assertEqual('void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic)\n{\n RootFindingInfo rfi = { constants, computedConstants, algebraic };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(False, False)) + self.assertEqual('void findRoot[INDEX](double *constants, double *computedConstants, double *algebraicVariables)\n{\n RootFindingInfo rfi = { constants, computedConstants, algebraicVariables };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(False, False)) g.setFindRootMethodString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(False, False)) - self.assertEqual('void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic, double *externals)\n{\n RootFindingInfo rfi = { constants, computedConstants, algebraic, externals };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(False, True)) + self.assertEqual('void findRoot[INDEX](double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables)\n{\n RootFindingInfo rfi = { constants, computedConstants, algebraicVariables, externalVariables };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(False, True)) g.setFindRootMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(False, True)) - self.assertEqual('void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(True, False)) + self.assertEqual('void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n{\n RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(True, False)) g.setFindRootMethodString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(True, False)) - self.assertEqual('void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals)\n{\n RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(True, True)) + self.assertEqual('void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables)\n{\n RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables };\n double u[[SIZE]];\n\n[CODE]}\n', g.findRootMethodString(True, True)) g.setFindRootMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.findRootMethodString(True, True)) @@ -1801,19 +1801,19 @@ def test_objective_function_method_string(self): g = GeneratorProfile() - self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n\n[CODE]}\n', g.objectiveFunctionMethodString(False, False)) + self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n\n[CODE]}\n', g.objectiveFunctionMethodString(False, False)) g.setObjectiveFunctionMethodString(False, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(False, False)) - self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n double *externals = ((RootFindingInfo *) data)->externals;\n\n[CODE]}\n', g.objectiveFunctionMethodString(False, True)) + self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n double *externalVariables = ((RootFindingInfo *) data)->externalVariables;\n\n[CODE]}\n', g.objectiveFunctionMethodString(False, True)) g.setObjectiveFunctionMethodString(False, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(False, True)) - self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double voi = ((RootFindingInfo *) data)->voi;\n double *states = ((RootFindingInfo *) data)->states;\n double *rates = ((RootFindingInfo *) data)->rates;\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n\n[CODE]}\n', g.objectiveFunctionMethodString(True, False)) + self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double voi = ((RootFindingInfo *) data)->voi;\n double *states = ((RootFindingInfo *) data)->states;\n double *rates = ((RootFindingInfo *) data)->rates;\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n\n[CODE]}\n', g.objectiveFunctionMethodString(True, False)) g.setObjectiveFunctionMethodString(True, False, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(True, False)) - self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double voi = ((RootFindingInfo *) data)->voi;\n double *states = ((RootFindingInfo *) data)->states;\n double *rates = ((RootFindingInfo *) data)->rates;\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraic = ((RootFindingInfo *) data)->algebraic;\n double *externals = ((RootFindingInfo *) data)->externals;\n\n[CODE]}\n', g.objectiveFunctionMethodString(True, True)) + self.assertEqual('void objectiveFunction[INDEX](double *u, double *f, void *data)\n{\n double voi = ((RootFindingInfo *) data)->voi;\n double *states = ((RootFindingInfo *) data)->states;\n double *rates = ((RootFindingInfo *) data)->rates;\n double *constants = ((RootFindingInfo *) data)->constants;\n double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n double *externalVariables = ((RootFindingInfo *) data)->externalVariables;\n\n[CODE]}\n', g.objectiveFunctionMethodString(True, True)) g.setObjectiveFunctionMethodString(True, True, GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.objectiveFunctionMethodString(True, True)) diff --git a/tests/bindings/python/test_issue.py b/tests/bindings/python/test_issue.py index 3de5258c4..823badef5 100644 --- a/tests/bindings/python/test_issue.py +++ b/tests/bindings/python/test_issue.py @@ -31,7 +31,7 @@ def test_reference_rule_enum(self): self.assertIsInstance(Issue.ReferenceRule.ANALYSER_EXTERNAL_VARIABLE_VOI, int) self.assertIsInstance(Issue.ReferenceRule.ANALYSER_ODE_NOT_FIRST_ORDER, int) self.assertIsInstance(Issue.ReferenceRule.ANALYSER_STATE_NOT_INITIALISED, int) - self.assertIsInstance(Issue.ReferenceRule.ANALYSER_STATE_RATE_AS_ALGEBRAIC, int) + self.assertIsInstance(Issue.ReferenceRule.ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE, int) self.assertIsInstance(Issue.ReferenceRule.ANALYSER_UNITS, int) self.assertIsInstance(Issue.ReferenceRule.ANALYSER_UNLINKED_UNITS, int) self.assertIsInstance(Issue.ReferenceRule.ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE, int) diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 4e71511c8..0f933ffe7 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -460,13 +460,13 @@ TEST(Coverage, analyser) EXPECT_EQ(size_t(0), analyserModel->computedConstants().size()); EXPECT_EQ(nullptr, analyserModel->computedConstant(0)); - EXPECT_EQ(size_t(0), analyserModel->algebraicCount()); - EXPECT_EQ(size_t(0), analyserModel->algebraic().size()); - EXPECT_EQ(nullptr, analyserModel->algebraic(0)); + EXPECT_EQ(size_t(0), analyserModel->algebraicVariableCount()); + EXPECT_EQ(size_t(0), analyserModel->algebraicVariables().size()); + EXPECT_EQ(nullptr, analyserModel->algebraicVariable(0)); - EXPECT_EQ(size_t(0), analyserModel->externalCount()); - EXPECT_EQ(size_t(0), analyserModel->externals().size()); - EXPECT_EQ(nullptr, analyserModel->external(0)); + EXPECT_EQ(size_t(0), analyserModel->externalVariableCount()); + EXPECT_EQ(size_t(0), analyserModel->externalVariables().size()); + EXPECT_EQ(nullptr, analyserModel->externalVariable(0)); EXPECT_EQ(size_t(0), analyserModel->equationCount()); EXPECT_EQ(size_t(0), analyserModel->equations().size()); @@ -560,7 +560,7 @@ TEST(Coverage, analyserTypes) auto analyserModel = analyser->model(); EXPECT_EQ("algebraic", libcellml::AnalyserEquation::typeAsString(analyserModel->equation(0)->type())); - EXPECT_EQ("algebraic", libcellml::AnalyserVariable::typeAsString(analyserModel->algebraic(0)->type())); + EXPECT_EQ("algebraic_variable", libcellml::AnalyserVariable::typeAsString(analyserModel->algebraicVariable(0)->type())); } void checkAstTypeAsString(const libcellml::AnalyserEquationAstPtr &ast) @@ -598,8 +598,8 @@ TEST(Coverage, generator) EXPECT_EQ(size_t(1), analyserModel->stateCount()); EXPECT_EQ(size_t(7), analyserModel->constantCount()); EXPECT_EQ(size_t(199), analyserModel->computedConstantCount()); - EXPECT_EQ(size_t(2), analyserModel->algebraicCount()); - EXPECT_EQ(size_t(1), analyserModel->externalCount()); + EXPECT_EQ(size_t(2), analyserModel->algebraicVariableCount()); + EXPECT_EQ(size_t(1), analyserModel->externalVariableCount()); EXPECT_EQ(size_t(203), analyserModel->equationCount()); EXPECT_NE(nullptr, analyserModel->voi()); @@ -617,12 +617,12 @@ TEST(Coverage, generator) EXPECT_NE(nullptr, analyserModel->computedConstant(0)); EXPECT_NE(nullptr, analyserModel->computedConstant(0)->equation(0)->computedConstant(0)); EXPECT_EQ(nullptr, analyserModel->computedConstant(analyserModel->computedConstantCount())); - EXPECT_NE(nullptr, analyserModel->algebraic(0)); - EXPECT_NE(nullptr, analyserModel->algebraic(0)->equation(0)->algebraic(0)); - EXPECT_EQ(nullptr, analyserModel->algebraic(analyserModel->algebraicCount())); - EXPECT_NE(nullptr, analyserModel->external(0)); - EXPECT_NE(nullptr, analyserModel->external(0)->equation(0)->external(0)); - EXPECT_EQ(nullptr, analyserModel->external(analyserModel->algebraicCount())); + EXPECT_NE(nullptr, analyserModel->algebraicVariable(0)); + EXPECT_NE(nullptr, analyserModel->algebraicVariable(0)->equation(0)->algebraicVariable(0)); + EXPECT_EQ(nullptr, analyserModel->algebraicVariable(analyserModel->algebraicVariableCount())); + EXPECT_NE(nullptr, analyserModel->externalVariable(0)); + EXPECT_NE(nullptr, analyserModel->externalVariable(0)->equation(0)->externalVariable(0)); + EXPECT_EQ(nullptr, analyserModel->externalVariable(analyserModel->algebraicVariableCount())); EXPECT_EQ(size_t(1), analyserModel->equation(0)->stateCount()); EXPECT_EQ(size_t(1), analyserModel->equation(0)->states().size()); EXPECT_NE(nullptr, analyserModel->equation(0)->state(0)); @@ -640,14 +640,14 @@ TEST(Coverage, generator) EXPECT_EQ(size_t(0), analyserModel->equation(199)->computedConstants().size()); EXPECT_EQ(nullptr, analyserModel->equation(199)->computedConstant(0)); EXPECT_EQ(nullptr, analyserModel->equation(199)->computedConstant(analyserModel->equation(199)->computedConstantCount())); - EXPECT_NE(size_t(0), analyserModel->equation(199)->algebraicCount()); - EXPECT_NE(size_t(0), analyserModel->equation(199)->algebraic().size()); - EXPECT_NE(nullptr, analyserModel->equation(199)->algebraic(0)); - EXPECT_EQ(nullptr, analyserModel->equation(199)->algebraic(analyserModel->equation(199)->algebraicCount())); - EXPECT_EQ(size_t(0), analyserModel->equation(199)->externalCount()); - EXPECT_EQ(size_t(0), analyserModel->equation(199)->externals().size()); - EXPECT_EQ(nullptr, analyserModel->equation(199)->external(0)); - EXPECT_EQ(nullptr, analyserModel->equation(199)->external(analyserModel->equation(199)->externalCount())); + EXPECT_NE(size_t(0), analyserModel->equation(199)->algebraicVariableCount()); + EXPECT_NE(size_t(0), analyserModel->equation(199)->algebraicVariables().size()); + EXPECT_NE(nullptr, analyserModel->equation(199)->algebraicVariable(0)); + EXPECT_EQ(nullptr, analyserModel->equation(199)->algebraicVariable(analyserModel->equation(199)->algebraicVariableCount())); + EXPECT_EQ(size_t(0), analyserModel->equation(199)->externalVariableCount()); + EXPECT_EQ(size_t(0), analyserModel->equation(199)->externalVariables().size()); + EXPECT_EQ(nullptr, analyserModel->equation(199)->externalVariable(0)); + EXPECT_EQ(nullptr, analyserModel->equation(199)->externalVariable(analyserModel->equation(199)->externalVariableCount())); EXPECT_EQ(nullptr, analyserModel->equation(analyserModel->equationCount())); for (const auto &equation : analyserModel->equations()) { @@ -666,8 +666,8 @@ TEST(Coverage, generator) EXPECT_NE(nullptr, analyserModel->constant(i)->initialisingVariable()); } - for (size_t i = 0; i < analyserModel->algebraicCount(); ++i) { - EXPECT_NE(nullptr, analyserModel->algebraic(i)->initialisingVariable()); + for (size_t i = 0; i < analyserModel->algebraicVariableCount(); ++i) { + EXPECT_NE(nullptr, analyserModel->algebraicVariable(i)->initialisingVariable()); } EXPECT_EQ(nullptr, generator->model()); @@ -726,8 +726,8 @@ TEST(Coverage, generator) profile->setImplementationConstantCountString(""); profile->setImplementationComputedConstantCountString(""); - profile->setImplementationAlgebraicCountString(""); - profile->setImplementationExternalCountString(""); + profile->setImplementationAlgebraicVariableCountString(""); + profile->setImplementationExternalVariableCountString(""); profile->setVariableInfoObjectString(""); @@ -739,9 +739,9 @@ TEST(Coverage, generator) profile->setImplementationComputedConstantInfoString(""); - profile->setImplementationAlgebraicInfoString(""); + profile->setImplementationAlgebraicVariableInfoString(""); - profile->setImplementationExternalInfoString(""); + profile->setImplementationExternalVariableInfoString(""); profile->setVariableInfoEntryString(""); @@ -751,9 +751,9 @@ TEST(Coverage, generator) profile->setImplementationCreateComputedConstantsArrayMethodString(""); - profile->setImplementationCreateAlgebraicArrayMethodString(""); + profile->setImplementationCreateAlgebraicVariablesArrayMethodString(""); - profile->setImplementationCreateExternalsArrayMethodString(""); + profile->setImplementationCreateExternalVariablesArrayMethodString(""); profile->setImplementationDeleteArrayMethodString(""); @@ -811,11 +811,11 @@ TEST(Coverage, generator) profile->setInterfaceComputedConstantCountString(""); profile->setImplementationComputedConstantCountString(""); - profile->setInterfaceAlgebraicCountString(""); - profile->setImplementationAlgebraicCountString(""); + profile->setInterfaceAlgebraicVariableCountString(""); + profile->setImplementationAlgebraicVariableCountString(""); - profile->setInterfaceExternalCountString(""); - profile->setImplementationExternalCountString(""); + profile->setInterfaceExternalVariableCountString(""); + profile->setImplementationExternalVariableCountString(""); profile->setVariableInfoObjectString(""); @@ -831,11 +831,11 @@ TEST(Coverage, generator) profile->setInterfaceComputedConstantInfoString(""); profile->setImplementationComputedConstantInfoString(""); - profile->setInterfaceAlgebraicInfoString(""); - profile->setImplementationAlgebraicInfoString(""); + profile->setInterfaceAlgebraicVariableInfoString(""); + profile->setImplementationAlgebraicVariableInfoString(""); - profile->setInterfaceExternalInfoString(""); - profile->setImplementationExternalInfoString(""); + profile->setInterfaceExternalVariableInfoString(""); + profile->setImplementationExternalVariableInfoString(""); profile->setVariableInfoEntryString(""); diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index 1b8071fbf..ebef497d6 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -285,11 +285,11 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("extern const size_t COMPUTED_CONSTANT_COUNT;\n", generatorProfile->interfaceComputedConstantCountString()); EXPECT_EQ("const size_t COMPUTED_CONSTANT_COUNT = [COMPUTED_CONSTANT_COUNT];\n", generatorProfile->implementationComputedConstantCountString()); - EXPECT_EQ("extern const size_t ALGEBRAIC_COUNT;\n", generatorProfile->interfaceAlgebraicCountString()); - EXPECT_EQ("const size_t ALGEBRAIC_COUNT = [ALGEBRAIC_COUNT];\n", generatorProfile->implementationAlgebraicCountString()); + EXPECT_EQ("extern const size_t ALGEBRAIC_VARIABLE_COUNT;\n", generatorProfile->interfaceAlgebraicVariableCountString()); + EXPECT_EQ("const size_t ALGEBRAIC_VARIABLE_COUNT = [ALGEBRAIC_VARIABLE_COUNT];\n", generatorProfile->implementationAlgebraicVariableCountString()); - EXPECT_EQ("extern const size_t EXTERNAL_COUNT;\n", generatorProfile->interfaceExternalCountString()); - EXPECT_EQ("const size_t EXTERNAL_COUNT = [EXTERNAL_COUNT];\n", generatorProfile->implementationExternalCountString()); + EXPECT_EQ("extern const size_t EXTERNAL_VARIABLE_COUNT;\n", generatorProfile->interfaceExternalVariableCountString()); + EXPECT_EQ("const size_t EXTERNAL_VARIABLE_COUNT = [EXTERNAL_VARIABLE_COUNT];\n", generatorProfile->implementationExternalVariableCountString()); EXPECT_EQ("typedef struct {\n" " char name[[NAME_SIZE]];\n" @@ -319,17 +319,17 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "};\n", generatorProfile->implementationComputedConstantInfoString()); - EXPECT_EQ("extern const VariableInfo ALGEBRAIC_INFO[];\n", generatorProfile->interfaceAlgebraicInfoString()); + EXPECT_EQ("extern const VariableInfo ALGEBRAIC_INFO[];\n", generatorProfile->interfaceAlgebraicVariableInfoString()); EXPECT_EQ("const VariableInfo ALGEBRAIC_INFO[] = {\n" "[CODE]" "};\n", - generatorProfile->implementationAlgebraicInfoString()); + generatorProfile->implementationAlgebraicVariableInfoString()); - EXPECT_EQ("extern const VariableInfo EXTERNAL_INFO[];\n", generatorProfile->interfaceExternalInfoString()); + EXPECT_EQ("extern const VariableInfo EXTERNAL_INFO[];\n", generatorProfile->interfaceExternalVariableInfoString()); EXPECT_EQ("const VariableInfo EXTERNAL_INFO[] = {\n" "[CODE]" "};\n", - generatorProfile->implementationExternalInfoString()); + generatorProfile->implementationExternalVariableInfoString()); EXPECT_EQ("{\"[NAME]\", \"[UNITS]\", \"[COMPONENT]\"}", generatorProfile->variableInfoEntryString()); @@ -339,26 +339,26 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) EXPECT_EQ("rates", generatorProfile->ratesArrayString()); EXPECT_EQ("constants", generatorProfile->constantsArrayString()); EXPECT_EQ("computedConstants", generatorProfile->computedConstantsArrayString()); - EXPECT_EQ("algebraic", generatorProfile->algebraicArrayString()); - EXPECT_EQ("externals", generatorProfile->externalArrayString()); + EXPECT_EQ("algebraicVariables", generatorProfile->algebraicVariablesArrayString()); + EXPECT_EQ("externalVariables", generatorProfile->externalVariablesArrayString()); - EXPECT_EQ("typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(false)); - EXPECT_EQ("typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(true)); + EXPECT_EQ("typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(false)); + EXPECT_EQ("typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index);\n", generatorProfile->externalVariableMethodTypeDefinitionString(true)); - EXPECT_EQ("externalVariable(constants, computedConstants, algebraic, externals, [INDEX])", generatorProfile->externalVariableMethodCallString(false)); - EXPECT_EQ("externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, [INDEX])", generatorProfile->externalVariableMethodCallString(true)); + EXPECT_EQ("externalVariable(constants, computedConstants, algebraicVariables, externalVariables, [INDEX])", generatorProfile->externalVariableMethodCallString(false)); + EXPECT_EQ("externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, [INDEX])", generatorProfile->externalVariableMethodCallString(true)); EXPECT_EQ("typedef struct {\n" " double *constants;\n" " double *computedConstants;\n" - " double *algebraic;\n" + " double *algebraicVariables;\n" "} RootFindingInfo;\n", generatorProfile->rootFindingInfoObjectString(false, false)); EXPECT_EQ("typedef struct {\n" " double *constants;\n" " double *computedConstants;\n" - " double *algebraic;\n" - " double *externals;\n" + " double *algebraicVariables;\n" + " double *externalVariables;\n" "} RootFindingInfo;\n", generatorProfile->rootFindingInfoObjectString(false, true)); EXPECT_EQ("typedef struct {\n" @@ -367,7 +367,7 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) " double *rates;\n" " double *constants;\n" " double *computedConstants;\n" - " double *algebraic;\n" + " double *algebraicVariables;\n" "} RootFindingInfo;\n", generatorProfile->rootFindingInfoObjectString(true, false)); EXPECT_EQ("typedef struct {\n" @@ -376,48 +376,48 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) " double *rates;\n" " double *constants;\n" " double *computedConstants;\n" - " double *algebraic;\n" - " double *externals;\n" + " double *algebraicVariables;\n" + " double *externalVariables;\n" "} RootFindingInfo;\n", generatorProfile->rootFindingInfoObjectString(true, true)); EXPECT_EQ("extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *),\n" " double *u, size_t n, void *data);\n", generatorProfile->externNlaSolveMethodString()); - EXPECT_EQ("findRoot[INDEX](constants, computedConstants, algebraic);\n", + EXPECT_EQ("findRoot[INDEX](constants, computedConstants, algebraicVariables);\n", generatorProfile->findRootCallString(false, false)); - EXPECT_EQ("findRoot[INDEX](constants, computedConstants, algebraic, externals);\n", + EXPECT_EQ("findRoot[INDEX](constants, computedConstants, algebraicVariables, externalVariables);\n", generatorProfile->findRootCallString(false, true)); - EXPECT_EQ("findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic);\n", + EXPECT_EQ("findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraicVariables);\n", generatorProfile->findRootCallString(true, false)); - EXPECT_EQ("findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraic, externals);\n", + EXPECT_EQ("findRoot[INDEX](voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables);\n", generatorProfile->findRootCallString(true, true)); - EXPECT_EQ("void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic)\n" + EXPECT_EQ("void findRoot[INDEX](double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" - " RootFindingInfo rfi = { constants, computedConstants, algebraic };\n" + " RootFindingInfo rfi = { constants, computedConstants, algebraicVariables };\n" " double u[[SIZE]];\n" "\n" "[CODE]" "}\n", generatorProfile->findRootMethodString(false, false)); - EXPECT_EQ("void findRoot[INDEX](double *constants, double *computedConstants, double *algebraic, double *externals)\n" + EXPECT_EQ("void findRoot[INDEX](double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables)\n" "{\n" - " RootFindingInfo rfi = { constants, computedConstants, algebraic, externals };\n" + " RootFindingInfo rfi = { constants, computedConstants, algebraicVariables, externalVariables };\n" " double u[[SIZE]];\n" "\n" "[CODE]" "}\n", generatorProfile->findRootMethodString(false, true)); - EXPECT_EQ("void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + EXPECT_EQ("void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" - " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic };\n" + " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables };\n" " double u[[SIZE]];\n" "\n" "[CODE]" "}\n", generatorProfile->findRootMethodString(true, false)); - EXPECT_EQ("void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals)\n" + EXPECT_EQ("void findRoot[INDEX](double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables)\n" "{\n" - " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals };\n" + " RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables };\n" " double u[[SIZE]];\n" "\n" "[CODE]" @@ -435,7 +435,7 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "{\n" " double *constants = ((RootFindingInfo *) data)->constants;\n" " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" - " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" + " double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n" "\n" "[CODE]" "}\n", @@ -444,8 +444,8 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "{\n" " double *constants = ((RootFindingInfo *) data)->constants;\n" " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" - " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" - " double *externals = ((RootFindingInfo *) data)->externals;\n" + " double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n" + " double *externalVariables = ((RootFindingInfo *) data)->externalVariables;\n" "\n" "[CODE]" "}\n", @@ -457,7 +457,7 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) " double *rates = ((RootFindingInfo *) data)->rates;\n" " double *constants = ((RootFindingInfo *) data)->constants;\n" " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" - " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" + " double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n" "\n" "[CODE]" "}\n", @@ -469,8 +469,8 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) " double *rates = ((RootFindingInfo *) data)->rates;\n" " double *constants = ((RootFindingInfo *) data)->constants;\n" " double *computedConstants = ((RootFindingInfo *) data)->computedConstants;\n" - " double *algebraic = ((RootFindingInfo *) data)->algebraic;\n" - " double *externals = ((RootFindingInfo *) data)->externals;\n" + " double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables;\n" + " double *externalVariables = ((RootFindingInfo *) data)->externalVariables;\n" "\n" "[CODE]" "}\n", @@ -522,33 +522,33 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationCreateComputedConstantsArrayMethodString()); - EXPECT_EQ("double * createAlgebraicArray();\n", - generatorProfile->interfaceCreateAlgebraicArrayMethodString()); - EXPECT_EQ("double * createAlgebraicArray()\n" + EXPECT_EQ("double * createAlgebraicVariablesArray();\n", + generatorProfile->interfaceCreateAlgebraicVariablesArrayMethodString()); + EXPECT_EQ("double * createAlgebraicVariablesArray()\n" "{\n" - " double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double));\n" + " double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double));\n" "\n" - " for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) {\n" + " for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) {\n" " res[i] = NAN;\n" " }\n" "\n" " return res;\n" "}\n", - generatorProfile->implementationCreateAlgebraicArrayMethodString()); + generatorProfile->implementationCreateAlgebraicVariablesArrayMethodString()); - EXPECT_EQ("double * createExternalsArray();\n", - generatorProfile->interfaceCreateExternalsArrayMethodString()); - EXPECT_EQ("double * createExternalsArray()\n" + EXPECT_EQ("double * createExternalVariablesArray();\n", + generatorProfile->interfaceCreateExternalVariablesArrayMethodString()); + EXPECT_EQ("double * createExternalVariablesArray()\n" "{\n" - " double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double));\n" + " double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double));\n" "\n" - " for (size_t i = 0; i < EXTERNAL_COUNT; ++i) {\n" + " for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) {\n" " res[i] = NAN;\n" " }\n" "\n" " return res;\n" "}\n", - generatorProfile->implementationCreateExternalsArrayMethodString()); + generatorProfile->implementationCreateExternalVariablesArrayMethodString()); EXPECT_EQ("void deleteArray(double *array);\n", generatorProfile->interfaceDeleteArrayMethodString()); @@ -558,17 +558,17 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationDeleteArrayMethodString()); - EXPECT_EQ("void initialiseVariables(double *constants, double *computedConstants, double *algebraic);\n", + EXPECT_EQ("void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables);\n", generatorProfile->interfaceInitialiseVariablesMethodString(false)); - EXPECT_EQ("void initialiseVariables(double *constants, double *computedConstants, double *algebraic)\n" + EXPECT_EQ("void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationInitialiseVariablesMethodString(false)); - EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n", + EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n", generatorProfile->interfaceInitialiseVariablesMethodString(true)); - EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" "[CODE]" "}\n", @@ -582,49 +582,49 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationComputeComputedConstantsMethodString()); - EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n", + EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n", generatorProfile->interfaceComputeRatesMethodString(false)); - EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationComputeRatesMethodString(false)); - EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n", + EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable);\n", generatorProfile->interfaceComputeRatesMethodString(true)); - EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n" + EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationComputeRatesMethodString(true)); - EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic);\n", + EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraicVariables);\n", generatorProfile->interfaceComputeVariablesMethodString(false, false)); - EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic)\n" + EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationComputeVariablesMethodString(false, false)); - EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n", + EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable);\n", generatorProfile->interfaceComputeVariablesMethodString(false, true)); - EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n" + EXPECT_EQ("void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationComputeVariablesMethodString(false, true)); - EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n", + EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n", generatorProfile->interfaceComputeVariablesMethodString(true, false)); - EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" "[CODE]" "}\n", generatorProfile->implementationComputeVariablesMethodString(true, false)); - EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable);\n", + EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable);\n", generatorProfile->interfaceComputeVariablesMethodString(true, true)); - EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable)\n" + EXPECT_EQ("void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable)\n" "{\n" "[CODE]" "}\n", @@ -960,11 +960,11 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setInterfaceComputedConstantCountString(value); generatorProfile->setImplementationComputedConstantCountString(value); - generatorProfile->setInterfaceAlgebraicCountString(value); - generatorProfile->setImplementationAlgebraicCountString(value); + generatorProfile->setInterfaceAlgebraicVariableCountString(value); + generatorProfile->setImplementationAlgebraicVariableCountString(value); - generatorProfile->setInterfaceExternalCountString(value); - generatorProfile->setImplementationExternalCountString(value); + generatorProfile->setInterfaceExternalVariableCountString(value); + generatorProfile->setImplementationExternalVariableCountString(value); generatorProfile->setVariableInfoObjectString(value); @@ -980,11 +980,11 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setInterfaceComputedConstantInfoString(value); generatorProfile->setImplementationComputedConstantInfoString(value); - generatorProfile->setInterfaceAlgebraicInfoString(value); - generatorProfile->setImplementationAlgebraicInfoString(value); + generatorProfile->setInterfaceAlgebraicVariableInfoString(value); + generatorProfile->setImplementationAlgebraicVariableInfoString(value); - generatorProfile->setInterfaceExternalInfoString(value); - generatorProfile->setImplementationExternalInfoString(value); + generatorProfile->setInterfaceExternalVariableInfoString(value); + generatorProfile->setImplementationExternalVariableInfoString(value); generatorProfile->setVariableInfoEntryString(value); @@ -994,8 +994,8 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setRatesArrayString(value); generatorProfile->setConstantsArrayString(value); generatorProfile->setComputedConstantsArrayString(value); - generatorProfile->setAlgebraicArrayString(value); - generatorProfile->setExternalArrayString(value); + generatorProfile->setAlgebraicVariablesArrayString(value); + generatorProfile->setExternalVariablesArrayString(value); generatorProfile->setExternalVariableMethodTypeDefinitionString(false, value); generatorProfile->setExternalVariableMethodTypeDefinitionString(true, value); @@ -1042,11 +1042,11 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setInterfaceCreateComputedConstantsArrayMethodString(value); generatorProfile->setImplementationCreateComputedConstantsArrayMethodString(value); - generatorProfile->setInterfaceCreateAlgebraicArrayMethodString(value); - generatorProfile->setImplementationCreateAlgebraicArrayMethodString(value); + generatorProfile->setInterfaceCreateAlgebraicVariablesArrayMethodString(value); + generatorProfile->setImplementationCreateAlgebraicVariablesArrayMethodString(value); - generatorProfile->setInterfaceCreateExternalsArrayMethodString(value); - generatorProfile->setImplementationCreateExternalsArrayMethodString(value); + generatorProfile->setInterfaceCreateExternalVariablesArrayMethodString(value); + generatorProfile->setImplementationCreateExternalVariablesArrayMethodString(value); generatorProfile->setInterfaceDeleteArrayMethodString(value); generatorProfile->setImplementationDeleteArrayMethodString(value); @@ -1115,11 +1115,11 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->interfaceComputedConstantCountString()); EXPECT_EQ(value, generatorProfile->implementationComputedConstantCountString()); - EXPECT_EQ(value, generatorProfile->interfaceAlgebraicCountString()); - EXPECT_EQ(value, generatorProfile->implementationAlgebraicCountString()); + EXPECT_EQ(value, generatorProfile->interfaceAlgebraicVariableCountString()); + EXPECT_EQ(value, generatorProfile->implementationAlgebraicVariableCountString()); - EXPECT_EQ(value, generatorProfile->interfaceExternalCountString()); - EXPECT_EQ(value, generatorProfile->implementationExternalCountString()); + EXPECT_EQ(value, generatorProfile->interfaceExternalVariableCountString()); + EXPECT_EQ(value, generatorProfile->implementationExternalVariableCountString()); EXPECT_EQ(value, generatorProfile->variableInfoObjectString()); @@ -1135,11 +1135,11 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->interfaceComputedConstantInfoString()); EXPECT_EQ(value, generatorProfile->implementationComputedConstantInfoString()); - EXPECT_EQ(value, generatorProfile->interfaceAlgebraicInfoString()); - EXPECT_EQ(value, generatorProfile->implementationAlgebraicInfoString()); + EXPECT_EQ(value, generatorProfile->interfaceAlgebraicVariableInfoString()); + EXPECT_EQ(value, generatorProfile->implementationAlgebraicVariableInfoString()); - EXPECT_EQ(value, generatorProfile->interfaceExternalInfoString()); - EXPECT_EQ(value, generatorProfile->implementationExternalInfoString()); + EXPECT_EQ(value, generatorProfile->interfaceExternalVariableInfoString()); + EXPECT_EQ(value, generatorProfile->implementationExternalVariableInfoString()); EXPECT_EQ(value, generatorProfile->variableInfoEntryString()); @@ -1149,8 +1149,8 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->ratesArrayString()); EXPECT_EQ(value, generatorProfile->constantsArrayString()); EXPECT_EQ(value, generatorProfile->computedConstantsArrayString()); - EXPECT_EQ(value, generatorProfile->algebraicArrayString()); - EXPECT_EQ(value, generatorProfile->externalArrayString()); + EXPECT_EQ(value, generatorProfile->algebraicVariablesArrayString()); + EXPECT_EQ(value, generatorProfile->externalVariablesArrayString()); EXPECT_EQ(value, generatorProfile->externalVariableMethodTypeDefinitionString(false)); EXPECT_EQ(value, generatorProfile->externalVariableMethodTypeDefinitionString(true)); @@ -1197,11 +1197,11 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->interfaceCreateComputedConstantsArrayMethodString()); EXPECT_EQ(value, generatorProfile->implementationCreateComputedConstantsArrayMethodString()); - EXPECT_EQ(value, generatorProfile->interfaceCreateAlgebraicArrayMethodString()); - EXPECT_EQ(value, generatorProfile->implementationCreateAlgebraicArrayMethodString()); + EXPECT_EQ(value, generatorProfile->interfaceCreateAlgebraicVariablesArrayMethodString()); + EXPECT_EQ(value, generatorProfile->implementationCreateAlgebraicVariablesArrayMethodString()); - EXPECT_EQ(value, generatorProfile->interfaceCreateExternalsArrayMethodString()); - EXPECT_EQ(value, generatorProfile->implementationCreateExternalsArrayMethodString()); + EXPECT_EQ(value, generatorProfile->interfaceCreateExternalVariablesArrayMethodString()); + EXPECT_EQ(value, generatorProfile->implementationCreateExternalVariablesArrayMethodString()); EXPECT_EQ(value, generatorProfile->interfaceDeleteArrayMethodString()); EXPECT_EQ(value, generatorProfile->implementationDeleteArrayMethodString()); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index fe97e027b..59623d2dd 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 7; const size_t COMPUTED_CONSTANT_COUNT = 199; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; +const size_t EXTERNAL_VARIABLE_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "my_component"}; @@ -355,22 +355,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -388,8 +388,8 @@ typedef struct { double *rates; double *constants; double *computedConstants; - double *algebraic; - double *externals; + double *algebraicVariables; + double *externalVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -402,31 +402,31 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; - f[0] = algebraic[1]+algebraic[0]+states[0]-0.0; - f[1] = algebraic[1]-algebraic[0]-(computedConstants[198]+computedConstants[197]); + f[0] = algebraicVariables[1]+algebraicVariables[0]+states[0]-0.0; + f[1] = algebraicVariables[1]-algebraicVariables[0]-(computedConstants[198]+computedConstants[197]); } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[2]; - u[0] = algebraic[0]; - u[1] = algebraic[1]; + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; constants[0] = 1.23; @@ -448,8 +448,8 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[186] = NAN; computedConstants[198] = 1.0; computedConstants[197] = 3.0; - algebraic[0] = 2.0; - algebraic[1] = 1.0; + algebraicVariables[0] = 2.0; + algebraicVariables[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -643,13 +643,13 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[196] = -(constants[1] && constants[0])+-((constants[2] > constants[3])?constants[0]:NAN); } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - findRoot0(voi, states, rates, constants, computedConstants, algebraic, externals); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 363681273..97423973a 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[38]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index d777cd145..f78a1029c 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -114,22 +114,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -147,8 +147,8 @@ typedef struct { double *rates; double *constants; double *computedConstants; - double *algebraic; - double *externals; + double *algebraicVariables; + double *externalVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -161,31 +161,31 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; - f[0] = algebraic[1]+algebraic[0]+states[0]-0.0; - f[1] = algebraic[1]-algebraic[0]-(computedConstants[198]+computedConstants[197]); + f[0] = algebraicVariables[1]+algebraicVariables[0]+states[0]-0.0; + f[1] = algebraicVariables[1]-algebraicVariables[0]-(computedConstants[198]+computedConstants[197]); } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[2]; - u[0] = algebraic[0]; - u[1] = algebraic[1]; + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; constants[0] = 1.23; @@ -207,8 +207,8 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[186] = NAN; computedConstants[198] = 1.0; computedConstants[197] = 3.0; - algebraic[0] = 2.0; - algebraic[1] = 1.0; + algebraicVariables[0] = 2.0; + algebraicVariables[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -402,13 +402,13 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[196] = -and(constants[1], constants[0])+-((gt(constants[2], constants[3]))?constants[0]:NAN); } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - findRoot0(voi, states, rates, constants, computedConstants, algebraic, externals); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index 5e05de246..a42db6021 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -7,14 +7,14 @@ double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index 5329446f6..ce4cbac5b 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 7; const size_t COMPUTED_CONSTANT_COUNT = 199; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; +const size_t EXTERNAL_VARIABLE_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "my_component"}; @@ -355,22 +355,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -388,8 +388,8 @@ typedef struct { double *rates; double *constants; double *computedConstants; - double *algebraic; - double *externals; + double *algebraicVariables; + double *externalVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -402,31 +402,31 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; - f[0] = algebraic[1]+algebraic[0]+states[0]-0.0; - f[1] = algebraic[1]-algebraic[0]-(computedConstants[198]+computedConstants[197]); + f[0] = algebraicVariables[1]+algebraicVariables[0]+states[0]-0.0; + f[1] = algebraicVariables[1]-algebraicVariables[0]-(computedConstants[198]+computedConstants[197]); } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[2]; - u[0] = algebraic[0]; - u[1] = algebraic[1]; + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; constants[0] = 1.23; @@ -448,8 +448,8 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl computedConstants[186] = NAN; computedConstants[198] = 1.0; computedConstants[197] = 3.0; - algebraic[0] = 2.0; - algebraic[1] = 1.0; + algebraicVariables[0] = 2.0; + algebraicVariables[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -643,13 +643,13 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[196] = -(constants[1] && constants[0])+-((constants[2] > constants[3])?constants[0]:NAN); } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - findRoot0(voi, states, rates, constants, computedConstants, algebraic, externals); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 546e7d451..2dc0c3178 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[38]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesVector(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index a98029674..0d6c52b57 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -10,8 +10,8 @@ STATE_COUNT = 1 CONSTANT_COUNT = 7 COMPUTED_CONSTANT_COUNT = 199 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 2 +EXTERNAL_VARIABLE_COUNT = 1 VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} @@ -355,12 +355,12 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT from nlasolver import nla_solve @@ -372,29 +372,29 @@ def objective_function_0(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[0] = u[0] - algebraic[1] = u[1] + algebraicVariables[0] = u[0] + algebraicVariables[1] = u[1] - f[0] = algebraic[1]+algebraic[0]+states[0]-0.0 - f[1] = algebraic[1]-algebraic[0]-(computed_constants[198]+computed_constants[197]) + f[0] = algebraicVariables[1]+algebraicVariables[0]+states[0]-0.0 + f[1] = algebraicVariables[1]-algebraicVariables[0]-(computed_constants[198]+computed_constants[197]) -def find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*2 - u[0] = algebraic[0] - u[1] = algebraic[1] + u[0] = algebraicVariables[0] + u[1] = algebraicVariables[1] - u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[0] = u[0] - algebraic[1] = u[1] + algebraicVariables[0] = u[0] + algebraicVariables[1] = u[1] -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 constants[0] = 1.23 constants[1] = 123.0 @@ -415,8 +415,8 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic computed_constants[186] = nan computed_constants[198] = 1.0 computed_constants[197] = 3.0 - algebraic[0] = 2.0 - algebraic[1] = 1.0 + algebraicVariables[0] = 2.0 + algebraicVariables[1] = 1.0 def compute_computed_constants(constants, computed_constants): @@ -609,10 +609,10 @@ def compute_computed_constants(constants, computed_constants): computed_constants[196] = -and_func(constants[1], constants[0])+-(constants[0] if gt_func(constants[2], constants[3]) else nan) -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals) +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index 6cd0aa81b..d50018ceb 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -84,8 +84,8 @@ typedef struct { double *rates; double *constants; double *computedConstants; - double *algebraic; - double *externals; + double *algebraicVariables; + double *externalVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -98,28 +98,28 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; - f[0] = algebraic[1]+algebraic[0]+states[0]-0.0; - f[1] = algebraic[1]-algebraic[0]-(computedConstants[198]+computedConstants[197]); + f[0] = algebraicVariables[1]+algebraicVariables[0]+states[0]-0.0; + f[1] = algebraicVariables[1]-algebraicVariables[0]-(computedConstants[198]+computedConstants[197]); } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[2]; - u[0] = algebraic[0]; - u[1] = algebraic[1]; + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; } void computeComputedConstants(double *constants, double *computedConstants) @@ -313,7 +313,7 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[196] = -(constants[1] && constants[0])+-piecewise(constants[2] > constants[3], constants[0], NAN); } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { rates[0] = 1.0; } diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index dc48c0cc9..536ff31f0 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -10,8 +10,8 @@ STATE_COUNT = 1 CONSTANT_COUNT = 7 COMPUTED_CONSTANT_COUNT = 199 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 2 +EXTERNAL_VARIABLE_COUNT = 1 VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} @@ -355,12 +355,12 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT from nlasolver import nla_solve @@ -372,29 +372,29 @@ def objective_function_0(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[0] = u[0] - algebraic[1] = u[1] + algebraicVariables[0] = u[0] + algebraicVariables[1] = u[1] - f[0] = algebraic[1]+algebraic[0]+states[0]-0.0 - f[1] = algebraic[1]-algebraic[0]-(computed_constants[198]+computed_constants[197]) + f[0] = algebraicVariables[1]+algebraicVariables[0]+states[0]-0.0 + f[1] = algebraicVariables[1]-algebraicVariables[0]-(computed_constants[198]+computed_constants[197]) -def find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*2 - u[0] = algebraic[0] - u[1] = algebraic[1] + u[0] = algebraicVariables[0] + u[1] = algebraicVariables[1] - u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[0] = u[0] - algebraic[1] = u[1] + algebraicVariables[0] = u[0] + algebraicVariables[1] = u[1] -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 constants[0] = 1.23 constants[1] = 123.0 @@ -415,8 +415,8 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic computed_constants[186] = nan computed_constants[198] = 1.0 computed_constants[197] = 3.0 - algebraic[0] = 2.0 - algebraic[1] = 1.0 + algebraicVariables[0] = 2.0 + algebraicVariables[1] = 1.0 def compute_computed_constants(constants, computed_constants): @@ -609,10 +609,10 @@ def compute_computed_constants(constants, computed_constants): computed_constants[196] = -and_func(constants[1], constants[0])+-(constants[0] if gt_func(constants[2], constants[3]) else nan) -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals) +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index 391d5c0f7..8236dea1a 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 2; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { }; @@ -45,11 +45,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 1.0; } @@ -71,6 +71,6 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[1] = computedConstants[0]; } -void computeVariables(double *constants, double *computedConstants, double *algebraic) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 0324525ff..66710d411 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -10,8 +10,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; const VariableInfo CONSTANT_INFO[] = { }; @@ -49,22 +49,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -76,7 +76,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { } @@ -84,8 +84,8 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); - algebraic[0] = externals[0]; + externalVariables[0] = externalVariable(constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = externalVariables[0]; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index 9a7ba657b..c6a20ed23 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -9,8 +9,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[2]; @@ -25,13 +25,13 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 0de02dd14..116142e91 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -9,8 +9,8 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 CONSTANT_INFO = [ ] @@ -35,15 +35,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): pass @@ -51,6 +51,6 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) - algebraic[0] = externals[0] +def compute_variables(constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[0] = externalVariables[0] diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index 75cb90a18..56505017d 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -9,7 +9,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -23,10 +23,10 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index f79c8eaa7..80d464663 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -9,7 +9,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 2 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 CONSTANT_INFO = [ ] @@ -31,11 +31,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): computed_constants[0] = 1.0 @@ -43,5 +43,5 @@ def compute_computed_constants(constants, computed_constants): computed_constants[1] = computed_constants[0] -def compute_variables(constants, computed_constants, algebraic): +def compute_variables(constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index 1a2b2fdd7..6656fcabb 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { {"a", "dimensionless", "my_algebraic_eqn"} @@ -45,11 +45,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 1.0; } @@ -71,6 +71,6 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[0] = constants[0]; } -void computeVariables(double *constants, double *computedConstants, double *algebraic) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index 75cb90a18..56505017d 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -9,7 +9,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -23,10 +23,10 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index b8916eb81..a7d6c15c3 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -9,7 +9,7 @@ CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 CONSTANT_INFO = [ {"name": "a", "units": "dimensionless", "component": "my_algebraic_eqn"} @@ -31,11 +31,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): constants[0] = 1.0 @@ -43,5 +43,5 @@ def compute_computed_constants(constants, computed_constants): computed_constants[0] = constants[0] -def compute_variables(constants, computed_constants, algebraic): +def compute_variables(constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index ee8029b1a..3ed487d06 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { }; @@ -44,11 +44,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -60,7 +60,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 1.0; } @@ -69,6 +69,6 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index 43917db40..1aa5136cc 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -9,7 +9,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -23,10 +23,10 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index 6d49d79e9..2a1433127 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -9,7 +9,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 CONSTANT_INFO = [ ] @@ -30,11 +30,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): computed_constants[0] = 1.0 @@ -42,5 +42,5 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic): +def compute_variables(constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index a57e8c2db..8f8e8fe01 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "environment"}; @@ -63,11 +63,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; @@ -89,12 +89,12 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = computedConstants[0]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = rates[0]; + algebraicVariables[0] = rates[0]; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index 4be41afea..7f0d4418e 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index 4a585994f..a331fb1e0 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 VOI_INFO = {"name": "t", "units": "second", "component": "environment"} @@ -42,11 +42,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 @@ -55,9 +55,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = computed_constants[0] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = rates[0] +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = rates[0] diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 5d25c9d3a..4d871f841 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "my_component"}; @@ -63,11 +63,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; @@ -89,12 +89,12 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = computedConstants[0]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = rates[0]; + algebraicVariables[0] = rates[0]; } diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index 0cf4442b7..61940eb44 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index ca93354b6..4d2f1fb8f 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} @@ -42,11 +42,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 @@ -55,9 +55,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = computed_constants[0] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = rates[0] +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = rates[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index fe7c9e489..e62b78e41 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "environment"}; @@ -63,11 +63,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; @@ -89,12 +89,12 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = computedConstants[0]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = 2.0*states[0]; + algebraicVariables[0] = 2.0*states[0]; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index 9a705870e..a5586f626 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[3]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index 1f730f43a..a47d25b06 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 VOI_INFO = {"name": "t", "units": "second", "component": "environment"} @@ -42,11 +42,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 @@ -55,9 +55,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = computed_constants[0] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = 2.0*states[0] +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = 2.0*states[0] diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index c92de6531..498fb9add 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; const VariableInfo VOI_INFO = {"t", "second", "my_model"}; @@ -63,11 +63,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; @@ -89,12 +89,12 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = computedConstants[0]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = 2.0*states[0]; + algebraicVariables[0] = 2.0*states[0]; } diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index 53799e112..954a5c239 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[3]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 917811845..34f37edb7 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 VOI_INFO = {"name": "t", "units": "second", "component": "my_model"} @@ -42,11 +42,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 @@ -55,9 +55,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = computed_constants[0] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = 2.0*states[0] +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = 2.0*states[0] diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index 9b41a3723..bb0fdb72a 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; const VariableInfo CONSTANT_INFO[] = { }; @@ -47,11 +47,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -66,7 +66,7 @@ void deleteArray(double *array) typedef struct { double *constants; double *computedConstants; - double *algebraic; + double *algebraicVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -76,38 +76,38 @@ void objectiveFunction0(double *u, double *f, void *data) { double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; - f[0] = algebraic[0]+computedConstants[0]-(computedConstants[1]+computedConstants[2]); + f[0] = algebraicVariables[0]+computedConstants[0]-(computedConstants[1]+computedConstants[2]); } -void findRoot0(double *constants, double *computedConstants, double *algebraic) +void findRoot0(double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { constants, computedConstants, algebraic }; + RootFindingInfo rfi = { constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[0]; + u[0] = algebraicVariables[0]; nlaSolve(objectiveFunction0, u, 1, &rfi); - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 3.0; computedConstants[1] = 5.0; computedConstants[2] = 7.0; - algebraic[0] = 1.0; + algebraicVariables[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(constants, computedConstants, algebraic); + findRoot0(constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index d9b0310d4..3c6de9052 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -10,8 +10,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 2; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; const VariableInfo CONSTANT_INFO[] = { }; @@ -51,22 +51,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -81,8 +81,8 @@ void deleteArray(double *array) typedef struct { double *constants; double *computedConstants; - double *algebraic; - double *externals; + double *algebraicVariables; + double *externalVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -92,39 +92,39 @@ void objectiveFunction0(double *u, double *f, void *data) { double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; - f[0] = algebraic[0]+computedConstants[0]-(externals[0]+computedConstants[1]); + f[0] = algebraicVariables[0]+computedConstants[0]-(externalVariables[0]+computedConstants[1]); } -void findRoot0(double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot0(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[0]; + u[0] = algebraicVariables[0]; nlaSolve(objectiveFunction0, u, 1, &rfi); - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 3.0; computedConstants[1] = 7.0; - algebraic[0] = 1.0; + algebraicVariables[0] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); - findRoot0(constants, computedConstants, algebraic, externals); + externalVariables[0] = externalVariable(constants, computedConstants, algebraicVariables, externalVariables, 0); + findRoot0(constants, computedConstants, algebraicVariables, externalVariables); } diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index 9a7ba657b..c6a20ed23 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -9,8 +9,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[2]; @@ -25,13 +25,13 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index 78344f82b..b300a1abb 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -9,8 +9,8 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 2 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 CONSTANT_INFO = [ ] @@ -37,12 +37,12 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT from nlasolver import nla_solve @@ -51,34 +51,34 @@ def create_externals_array(): def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] - algebraic = data[2] - externals = data[3] + algebraic_variables = data[2] + external_variables = data[3] - algebraic[0] = u[0] + algebraicVariables[0] = u[0] - f[0] = algebraic[0]+computed_constants[0]-(externals[0]+computed_constants[1]) + f[0] = algebraicVariables[0]+computed_constants[0]-(externalVariables[0]+computed_constants[1]) -def find_root_0(constants, computed_constants, algebraic, externals): +def find_root_0(constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[0] + u[0] = algebraicVariables[0] - u = nla_solve(objective_function_0, u, 1, [constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_0, u, 1, [constants, computed_constants, algebraic_variables, external_variables]) - algebraic[0] = u[0] + algebraicVariables[0] = u[0] -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): computed_constants[0] = 3.0 computed_constants[1] = 7.0 - algebraic[0] = 1.0 + algebraicVariables[0] = 1.0 def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) - find_root_0(constants, computed_constants, algebraic, externals) +def compute_variables(constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(constants, computed_constants, algebraic_variables, external_variables, 0) + find_root_0(constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index 75cb90a18..56505017d 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -9,7 +9,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -23,10 +23,10 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index 38d180928..bf6400289 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -9,7 +9,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 CONSTANT_INFO = [ ] @@ -33,8 +33,8 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT from nlasolver import nla_solve @@ -43,33 +43,33 @@ def create_algebraic_array(): def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] - algebraic = data[2] + algebraic_variables = data[2] - algebraic[0] = u[0] + algebraicVariables[0] = u[0] - f[0] = algebraic[0]+computed_constants[0]-(computed_constants[1]+computed_constants[2]) + f[0] = algebraicVariables[0]+computed_constants[0]-(computed_constants[1]+computed_constants[2]) -def find_root_0(constants, computed_constants, algebraic): +def find_root_0(constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[0] + u[0] = algebraicVariables[0] - u = nla_solve(objective_function_0, u, 1, [constants, computed_constants, algebraic]) + u = nla_solve(objective_function_0, u, 1, [constants, computed_constants, algebraic_variables]) - algebraic[0] = u[0] + algebraicVariables[0] = u[0] -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): computed_constants[0] = 3.0 computed_constants[1] = 5.0 computed_constants[2] = 7.0 - algebraic[0] = 1.0 + algebraicVariables[0] = 1.0 def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic): - find_root_0(constants, computed_constants, algebraic) +def compute_variables(constants, computed_constants, algebraic_variables): + find_root_0(constants, computed_constants, algebraic_variables) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index 2a7a16f41..a4373bc28 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 3; const VariableInfo CONSTANT_INFO[] = { }; @@ -46,11 +46,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -65,7 +65,7 @@ void deleteArray(double *array) typedef struct { double *constants; double *computedConstants; - double *algebraic; + double *algebraicVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -75,45 +75,45 @@ void objectiveFunction0(double *u, double *f, void *data) { double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[0] = u[0]; - algebraic[1] = u[1]; - algebraic[2] = u[2]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; + algebraicVariables[2] = u[2]; - f[0] = 2.0*algebraic[2]+algebraic[1]-2.0*algebraic[0]-(-1.0); - f[1] = 3.0*algebraic[2]-3.0*algebraic[1]-algebraic[0]-5.0; - f[2] = algebraic[2]-2.0*algebraic[1]+3.0*algebraic[0]-6.0; + f[0] = 2.0*algebraicVariables[2]+algebraicVariables[1]-2.0*algebraicVariables[0]-(-1.0); + f[1] = 3.0*algebraicVariables[2]-3.0*algebraicVariables[1]-algebraicVariables[0]-5.0; + f[2] = algebraicVariables[2]-2.0*algebraicVariables[1]+3.0*algebraicVariables[0]-6.0; } -void findRoot0(double *constants, double *computedConstants, double *algebraic) +void findRoot0(double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { constants, computedConstants, algebraic }; + RootFindingInfo rfi = { constants, computedConstants, algebraicVariables }; double u[3]; - u[0] = algebraic[0]; - u[1] = algebraic[1]; - u[2] = algebraic[2]; + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; + u[2] = algebraicVariables[2]; nlaSolve(objectiveFunction0, u, 3, &rfi); - algebraic[0] = u[0]; - algebraic[1] = u[1]; - algebraic[2] = u[2]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; + algebraicVariables[2] = u[2]; } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = 1.0; - algebraic[1] = 1.0; - algebraic[2] = 1.0; + algebraicVariables[0] = 1.0; + algebraicVariables[1] = 1.0; + algebraicVariables[2] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(constants, computedConstants, algebraic); + findRoot0(constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c index 0cec3873f..7f9e8d52d 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c @@ -10,8 +10,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; -const size_t EXTERNAL_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; +const size_t EXTERNAL_VARIABLE_COUNT = 3; const VariableInfo CONSTANT_INFO[] = { }; @@ -50,22 +50,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { } @@ -85,9 +85,9 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); - externals[1] = externalVariable(constants, computedConstants, algebraic, externals, 1); - externals[2] = externalVariable(constants, computedConstants, algebraic, externals, 2); + externalVariables[0] = externalVariable(constants, computedConstants, algebraicVariables, externalVariables, 0); + externalVariables[1] = externalVariable(constants, computedConstants, algebraicVariables, externalVariables, 1); + externalVariables[2] = externalVariable(constants, computedConstants, algebraicVariables, externalVariables, 2); } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h index 43266515a..a976b36a9 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h @@ -9,8 +9,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[2]; @@ -25,13 +25,13 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py index 46528e56d..f0201f4a1 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py @@ -9,8 +9,8 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 -EXTERNAL_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 0 +EXTERNAL_VARIABLE_COUNT = 3 CONSTANT_INFO = [ ] @@ -36,15 +36,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): pass @@ -52,7 +52,7 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) - externals[1] = external_variable(constants, computed_constants, algebraic, externals, 1) - externals[2] = external_variable(constants, computed_constants, algebraic, externals, 2) +def compute_variables(constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(constants, computed_constants, algebraic_variables, external_variables, 0) + externalVariables[1] = external_variable(constants, computed_constants, algebraic_variables, external_variables, 1) + externalVariables[2] = external_variable(constants, computed_constants, algebraic_variables, external_variables, 2) diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index 074d991c3..f8a633bbc 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -9,7 +9,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -23,10 +23,10 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 62255be3c..2514ba0f2 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -9,7 +9,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 3 CONSTANT_INFO = [ ] @@ -32,8 +32,8 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT from nlasolver import nla_solve @@ -42,40 +42,40 @@ def create_algebraic_array(): def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] - algebraic = data[2] + algebraic_variables = data[2] - algebraic[0] = u[0] - algebraic[1] = u[1] - algebraic[2] = u[2] + algebraicVariables[0] = u[0] + algebraicVariables[1] = u[1] + algebraicVariables[2] = u[2] - f[0] = 2.0*algebraic[2]+algebraic[1]-2.0*algebraic[0]-(-1.0) - f[1] = 3.0*algebraic[2]-3.0*algebraic[1]-algebraic[0]-5.0 - f[2] = algebraic[2]-2.0*algebraic[1]+3.0*algebraic[0]-6.0 + f[0] = 2.0*algebraicVariables[2]+algebraicVariables[1]-2.0*algebraicVariables[0]-(-1.0) + f[1] = 3.0*algebraicVariables[2]-3.0*algebraicVariables[1]-algebraicVariables[0]-5.0 + f[2] = algebraicVariables[2]-2.0*algebraicVariables[1]+3.0*algebraicVariables[0]-6.0 -def find_root_0(constants, computed_constants, algebraic): +def find_root_0(constants, computed_constants, algebraic_variables): u = [nan]*3 - u[0] = algebraic[0] - u[1] = algebraic[1] - u[2] = algebraic[2] + u[0] = algebraicVariables[0] + u[1] = algebraicVariables[1] + u[2] = algebraicVariables[2] - u = nla_solve(objective_function_0, u, 3, [constants, computed_constants, algebraic]) + u = nla_solve(objective_function_0, u, 3, [constants, computed_constants, algebraic_variables]) - algebraic[0] = u[0] - algebraic[1] = u[1] - algebraic[2] = u[2] + algebraicVariables[0] = u[0] + algebraicVariables[1] = u[1] + algebraicVariables[2] = u[2] -def initialise_variables(constants, computed_constants, algebraic): - algebraic[0] = 1.0 - algebraic[1] = 1.0 - algebraic[2] = 1.0 +def initialise_variables(constants, computed_constants, algebraic_variables): + algebraicVariables[0] = 1.0 + algebraicVariables[1] = 1.0 + algebraicVariables[2] = 1.0 def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic): - find_root_0(constants, computed_constants, algebraic) +def compute_variables(constants, computed_constants, algebraic_variables): + find_root_0(constants, computed_constants, algebraic_variables) diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index 4807f0acd..17996b6af 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 2; const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 3; const VariableInfo CONSTANT_INFO[] = { {"y", "dimensionless", "my_algebraic_system"}, @@ -49,11 +49,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -68,7 +68,7 @@ void deleteArray(double *array) typedef struct { double *constants; double *computedConstants; - double *algebraic; + double *algebraicVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -78,35 +78,35 @@ void objectiveFunction0(double *u, double *f, void *data) { double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; - f[0] = 3.0*computedConstants[0]+2.0*algebraic[1]+algebraic[0]-57.0; - f[1] = computedConstants[0]+3.0*algebraic[1]-algebraic[0]-19.0; + f[0] = 3.0*computedConstants[0]+2.0*algebraicVariables[1]+algebraicVariables[0]-57.0; + f[1] = computedConstants[0]+3.0*algebraicVariables[1]-algebraicVariables[0]-19.0; } -void findRoot0(double *constants, double *computedConstants, double *algebraic) +void findRoot0(double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { constants, computedConstants, algebraic }; + RootFindingInfo rfi = { constants, computedConstants, algebraicVariables }; double u[2]; - u[0] = algebraic[0]; - u[1] = algebraic[1]; + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 5.0; constants[1] = 3.0; - algebraic[0] = 1.0; - algebraic[1] = 1.0; + algebraicVariables[0] = 1.0; + algebraicVariables[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -114,8 +114,8 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[0] = 3.0*constants[1]+constants[0]; } -void computeVariables(double *constants, double *computedConstants, double *algebraic) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(constants, computedConstants, algebraic); - algebraic[2] = algebraic[1]+algebraic[0]; + findRoot0(constants, computedConstants, algebraicVariables); + algebraicVariables[2] = algebraicVariables[1]+algebraicVariables[0]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index 074d991c3..f8a633bbc 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -9,7 +9,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -23,10 +23,10 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 44fb1e844..9c8678d24 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -9,7 +9,7 @@ CONSTANT_COUNT = 2 COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 3 CONSTANT_INFO = [ {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"}, @@ -35,8 +35,8 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT from nlasolver import nla_solve @@ -45,38 +45,38 @@ def create_algebraic_array(): def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] - algebraic = data[2] + algebraic_variables = data[2] - algebraic[0] = u[0] - algebraic[1] = u[1] + algebraicVariables[0] = u[0] + algebraicVariables[1] = u[1] - f[0] = 3.0*computed_constants[0]+2.0*algebraic[1]+algebraic[0]-57.0 - f[1] = computed_constants[0]+3.0*algebraic[1]-algebraic[0]-19.0 + f[0] = 3.0*computed_constants[0]+2.0*algebraicVariables[1]+algebraicVariables[0]-57.0 + f[1] = computed_constants[0]+3.0*algebraicVariables[1]-algebraicVariables[0]-19.0 -def find_root_0(constants, computed_constants, algebraic): +def find_root_0(constants, computed_constants, algebraic_variables): u = [nan]*2 - u[0] = algebraic[0] - u[1] = algebraic[1] + u[0] = algebraicVariables[0] + u[1] = algebraicVariables[1] - u = nla_solve(objective_function_0, u, 2, [constants, computed_constants, algebraic]) + u = nla_solve(objective_function_0, u, 2, [constants, computed_constants, algebraic_variables]) - algebraic[0] = u[0] - algebraic[1] = u[1] + algebraicVariables[0] = u[0] + algebraicVariables[1] = u[1] -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): constants[0] = 5.0 constants[1] = 3.0 - algebraic[0] = 1.0 - algebraic[1] = 1.0 + algebraicVariables[0] = 1.0 + algebraicVariables[1] = 1.0 def compute_computed_constants(constants, computed_constants): computed_constants[0] = 3.0*constants[1]+constants[0] -def compute_variables(constants, computed_constants, algebraic): - find_root_0(constants, computed_constants, algebraic) - algebraic[2] = algebraic[1]+algebraic[0] +def compute_variables(constants, computed_constants, algebraic_variables): + find_root_0(constants, computed_constants, algebraic_variables) + algebraicVariables[2] = algebraicVariables[1]+algebraicVariables[0] diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index 1c4a79701..23ee83b1c 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 2; const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 3; const VariableInfo CONSTANT_INFO[] = { {"y", "dimensionless", "my_algebraic_system"}, @@ -49,11 +49,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -68,7 +68,7 @@ void deleteArray(double *array) typedef struct { double *constants; double *computedConstants; - double *algebraic; + double *algebraicVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -78,35 +78,35 @@ void objectiveFunction0(double *u, double *f, void *data) { double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; - f[0] = 3.0*computedConstants[0]+2.0*algebraic[1]+algebraic[0]-57.0; - f[1] = computedConstants[0]+3.0*algebraic[1]-algebraic[0]-19.0; + f[0] = 3.0*computedConstants[0]+2.0*algebraicVariables[1]+algebraicVariables[0]-57.0; + f[1] = computedConstants[0]+3.0*algebraicVariables[1]-algebraicVariables[0]-19.0; } -void findRoot0(double *constants, double *computedConstants, double *algebraic) +void findRoot0(double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { constants, computedConstants, algebraic }; + RootFindingInfo rfi = { constants, computedConstants, algebraicVariables }; double u[2]; - u[0] = algebraic[0]; - u[1] = algebraic[1]; + u[0] = algebraicVariables[0]; + u[1] = algebraicVariables[1]; nlaSolve(objectiveFunction0, u, 2, &rfi); - algebraic[0] = u[0]; - algebraic[1] = u[1]; + algebraicVariables[0] = u[0]; + algebraicVariables[1] = u[1]; } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 5.0; constants[1] = 3.0; - algebraic[0] = 1.0; - algebraic[1] = 1.0; + algebraicVariables[0] = 1.0; + algebraicVariables[1] = 1.0; } void computeComputedConstants(double *constants, double *computedConstants) @@ -114,8 +114,8 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[0] = 3.0*constants[1]+constants[0]; } -void computeVariables(double *constants, double *computedConstants, double *algebraic) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(constants, computedConstants, algebraic); - algebraic[2] = algebraic[1]+algebraic[0]; + findRoot0(constants, computedConstants, algebraicVariables); + algebraicVariables[2] = algebraicVariables[1]+algebraicVariables[0]; } diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index 074d991c3..f8a633bbc 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -9,7 +9,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -23,10 +23,10 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 44fb1e844..9c8678d24 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -9,7 +9,7 @@ CONSTANT_COUNT = 2 COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 3 CONSTANT_INFO = [ {"name": "y", "units": "dimensionless", "component": "my_algebraic_system"}, @@ -35,8 +35,8 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT from nlasolver import nla_solve @@ -45,38 +45,38 @@ def create_algebraic_array(): def objective_function_0(u, f, data): constants = data[0] computed_constants = data[1] - algebraic = data[2] + algebraic_variables = data[2] - algebraic[0] = u[0] - algebraic[1] = u[1] + algebraicVariables[0] = u[0] + algebraicVariables[1] = u[1] - f[0] = 3.0*computed_constants[0]+2.0*algebraic[1]+algebraic[0]-57.0 - f[1] = computed_constants[0]+3.0*algebraic[1]-algebraic[0]-19.0 + f[0] = 3.0*computed_constants[0]+2.0*algebraicVariables[1]+algebraicVariables[0]-57.0 + f[1] = computed_constants[0]+3.0*algebraicVariables[1]-algebraicVariables[0]-19.0 -def find_root_0(constants, computed_constants, algebraic): +def find_root_0(constants, computed_constants, algebraic_variables): u = [nan]*2 - u[0] = algebraic[0] - u[1] = algebraic[1] + u[0] = algebraicVariables[0] + u[1] = algebraicVariables[1] - u = nla_solve(objective_function_0, u, 2, [constants, computed_constants, algebraic]) + u = nla_solve(objective_function_0, u, 2, [constants, computed_constants, algebraic_variables]) - algebraic[0] = u[0] - algebraic[1] = u[1] + algebraicVariables[0] = u[0] + algebraicVariables[1] = u[1] -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): constants[0] = 5.0 constants[1] = 3.0 - algebraic[0] = 1.0 - algebraic[1] = 1.0 + algebraicVariables[0] = 1.0 + algebraicVariables[1] = 1.0 def compute_computed_constants(constants, computed_constants): computed_constants[0] = 3.0*constants[1]+constants[0] -def compute_variables(constants, computed_constants, algebraic): - find_root_0(constants, computed_constants, algebraic) - algebraic[2] = algebraic[1]+algebraic[0] +def compute_variables(constants, computed_constants, algebraic_variables): + find_root_0(constants, computed_constants, algebraic_variables) + algebraicVariables[2] = algebraicVariables[1]+algebraicVariables[0] diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index b9e31402a..6488fe2dd 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 2; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { }; @@ -45,11 +45,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 1.0; } @@ -71,6 +71,6 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[1] = computedConstants[0]; } -void computeVariables(double *constants, double *computedConstants, double *algebraic) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index 43917db40..1aa5136cc 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -9,7 +9,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -23,10 +23,10 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index a408121e0..82bea886a 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -9,7 +9,7 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 2 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 CONSTANT_INFO = [ ] @@ -31,11 +31,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): computed_constants[0] = 1.0 @@ -43,5 +43,5 @@ def compute_computed_constants(constants, computed_constants): computed_constants[1] = computed_constants[0] -def compute_variables(constants, computed_constants, algebraic): +def compute_variables(constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index 963beb354..e1048017a 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 2; const size_t COMPUTED_CONSTANT_COUNT = 2; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { {"L", "centimeter", "cell_geometry"}, @@ -47,11 +47,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -63,7 +63,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 0.01; constants[1] = 0.0011; @@ -75,6 +75,6 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[1] = 0.02*computedConstants[0]; } -void computeVariables(double *constants, double *computedConstants, double *algebraic) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 3776c80ae..35e13ec58 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -10,8 +10,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; -const size_t EXTERNAL_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; +const size_t EXTERNAL_VARIABLE_COUNT = 2; const VariableInfo CONSTANT_INFO[] = { }; @@ -51,22 +51,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { } @@ -86,10 +86,10 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); - externals[1] = externalVariable(constants, computedConstants, algebraic, externals, 1); - algebraic[0] = 1000.0*3.14*externals[1]*externals[1]*externals[0]; - algebraic[1] = 0.02*algebraic[0]; + externalVariables[0] = externalVariable(constants, computedConstants, algebraicVariables, externalVariables, 0); + externalVariables[1] = externalVariable(constants, computedConstants, algebraicVariables, externalVariables, 1); + algebraicVariables[0] = 1000.0*3.14*externalVariables[1]*externalVariables[1]*externalVariables[0]; + algebraicVariables[1] = 0.02*algebraicVariables[0]; } diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 0c30f64ab..597046bab 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -9,8 +9,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[6]; @@ -25,13 +25,13 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 5575d1949..57835e297 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -9,8 +9,8 @@ CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 -EXTERNAL_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 2 +EXTERNAL_VARIABLE_COUNT = 2 CONSTANT_INFO = [ ] @@ -37,15 +37,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): pass @@ -53,8 +53,8 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) - externals[1] = external_variable(constants, computed_constants, algebraic, externals, 1) - algebraic[0] = 1000.0*3.14*externals[1]*externals[1]*externals[0] - algebraic[1] = 0.02*algebraic[0] +def compute_variables(constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(constants, computed_constants, algebraic_variables, external_variables, 0) + externalVariables[1] = external_variable(constants, computed_constants, algebraic_variables, external_variables, 1) + algebraicVariables[0] = 1000.0*3.14*externalVariables[1]*externalVariables[1]*externalVariables[0] + algebraicVariables[1] = 0.02*algebraicVariables[0] diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index 599d9f367..6487ae239 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -9,7 +9,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[6]; @@ -23,10 +23,10 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index 9269a44f3..1fae0dca9 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -9,7 +9,7 @@ CONSTANT_COUNT = 2 COMPUTED_CONSTANT_COUNT = 2 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 CONSTANT_INFO = [ {"name": "L", "units": "centimeter", "component": "cell_geometry"}, @@ -33,11 +33,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): constants[0] = 0.01 constants[1] = 0.0011 @@ -47,5 +47,5 @@ def compute_computed_constants(constants, computed_constants): computed_constants[1] = 0.02*computed_constants[0] -def compute_variables(constants, computed_constants, algebraic): +def compute_variables(constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index cae325060..25d8af002 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; const VariableInfo VOI_INFO = {"t", "ms", "environment"}; @@ -64,11 +64,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; states[1] = 0.0; @@ -90,14 +90,14 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[1] = -states[0]*1.0; rates[0] = states[1]*1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0); - algebraic[1] = 2.0*states[1]; + algebraicVariables[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0); + algebraicVariables[1] = 2.0*states[1]; } diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index 158aaec2c..3c70ec191 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[20]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 0ba311b01..9f063568b 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 2 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 2 VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} @@ -43,11 +43,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 states[1] = 0.0 @@ -56,11 +56,11 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[1] = -states[0]*1.0 rates[0] = states[1]*1.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0) - algebraic[1] = 2.0*states[1] +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = states[0]+5.0*states[0]/3.0+1.0*exp(states[0]/2.0) + algebraicVariables[1] = 2.0*states[1] diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index a516d38f2..579c8df29 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -9,7 +9,7 @@ CONSTANT_COUNT = 9 COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 CONSTANT_INFO = [ {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss"}, @@ -39,11 +39,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): constants[0] = 810000.0 constants[1] = 150.0 constants[2] = 2.0 @@ -59,5 +59,5 @@ def compute_computed_constants(constants, computed_constants): computed_constants[0] = constants[8]*(constants[7]*constants[1]-constants[6]*constants[2])/(constants[5]*constants[2]+constants[4]*constants[1]+constants[3]*constants[2]*constants[1]+constants[0]) -def compute_variables(constants, computed_constants, algebraic): +def compute_variables(constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index d7e2e3723..d7252d5af 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment"}; @@ -62,11 +62,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 123.0; states[0] = constants[0]; @@ -88,11 +88,11 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 1.23; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index 4d8f0e475..b5a9edb2f 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 54cfda7c4..8c3c8e3fd 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} @@ -41,11 +41,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): constants[0] = 123.0 states[0] = constants[0] @@ -54,9 +54,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 1.23 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 160b9da73..9325bc1fe 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -10,7 +10,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 9; const size_t COMPUTED_CONSTANT_COUNT = 10; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo CONSTANT_INFO[] = { {"ind_c_mM", "mM", "constants"}, @@ -62,11 +62,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { constants[2] = 123.0; constants[1] = constants[2]; @@ -105,6 +105,6 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[9] = constants[7]+constants[8]; } -void computeVariables(double *constants, double *computedConstants, double *algebraic) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index 50f3ec5d0..a7ad0b8ef 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -9,7 +9,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[14]; @@ -23,10 +23,10 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index f3c4c08ae..0a51c8e9c 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -9,7 +9,7 @@ CONSTANT_COUNT = 9 COMPUTED_CONSTANT_COUNT = 10 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 CONSTANT_INFO = [ {"name": "ind_c_mM", "units": "mM", "component": "constants"}, @@ -48,11 +48,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): constants[2] = 123.0 constants[1] = constants[2] constants[0] = constants[1] @@ -77,5 +77,5 @@ def compute_computed_constants(constants, computed_constants): computed_constants[9] = constants[7]+constants[8] -def compute_variables(constants, computed_constants, algebraic): +def compute_variables(constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 2767b1600..7f0ba89f9 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; const VariableInfo VOI_INFO = {"t", "ms", "environment"}; @@ -63,11 +63,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 123.0; } @@ -88,13 +88,13 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 1.23; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = 1000.0*rates[0]+1000.0*rates[0]; - algebraic[1] = 1000.0*0.001*rates[0]+1000.0*0.001*rates[0]; + algebraicVariables[0] = 1000.0*rates[0]+1000.0*rates[0]; + algebraicVariables[1] = 1000.0*0.001*rates[0]+1000.0*0.001*rates[0]; } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index 4d8f0e475..b5a9edb2f 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index 7c3699776..a909701f7 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 2 VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} @@ -42,11 +42,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 123.0 @@ -54,10 +54,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 1.23 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = 1000.0*rates[0]+1000.0*rates[0] - algebraic[1] = 1000.0*0.001*rates[0]+1000.0*0.001*rates[0] +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = 1000.0*rates[0]+1000.0*rates[0] + algebraicVariables[1] = 1000.0*0.001*rates[0]+1000.0*0.001*rates[0] diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index 91349947c..e4dafe1a9 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; const VariableInfo VOI_INFO = {"t", "ms", "environment"}; @@ -63,11 +63,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 123.0; } @@ -88,13 +88,13 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 1.23; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = states[0]+states[0]; - algebraic[1] = 0.001*states[0]+0.001*states[0]; + algebraicVariables[0] = states[0]+states[0]; + algebraicVariables[1] = 0.001*states[0]+0.001*states[0]; } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index 4d8f0e475..b5a9edb2f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index 5839a1ba2..fa3fdde88 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 2 VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} @@ -42,11 +42,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 123.0 @@ -54,10 +54,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 1.23 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = states[0]+states[0] - algebraic[1] = 0.001*states[0]+0.001*states[0] +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = states[0]+states[0] + algebraicVariables[1] = 0.001*states[0]+0.001*states[0] diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index 17a35c7d1..b1a893402 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment"}; @@ -62,11 +62,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 123.0; states[1] = 0.001*789.0; @@ -88,12 +88,12 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 1.23; rates[1] = 7.89; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index edd268903..cb00e12cd 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[3]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index e2ecdb690..3c776abce 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 2 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} @@ -41,11 +41,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 123.0 states[1] = 0.001*789.0 @@ -54,10 +54,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 1.23 rates[1] = 7.89 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index 3de73cc8c..246aed9c9 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 2; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment"}; @@ -64,11 +64,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 123.0; states[0] = constants[0]; @@ -92,12 +92,12 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 1.23; rates[1] = 7.89; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 85890db19..1712c68d5 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[7]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index e36bf3f5c..11b86584f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 2 CONSTANT_COUNT = 2 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} @@ -43,11 +43,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): constants[0] = 123.0 states[0] = constants[0] constants[1] = 789.0 @@ -58,10 +58,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 1.23 rates[1] = 7.89 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index e67ddcceb..b965e14f2 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "ms", "environment"}; @@ -62,11 +62,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 3.0; states[1] = 5.0; @@ -88,12 +88,12 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = voi/1.0; rates[1] = 0.001*voi/1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index 9e491081b..41e5207c3 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index 94a907a0b..d7f40ed86 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 2 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "ms", "component": "environment"} @@ -41,11 +41,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 3.0 states[1] = 5.0 @@ -54,10 +54,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = voi/1.0 rates[1] = 0.001*voi/1.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index 478d943df..b5890c16d 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment"}; @@ -63,11 +63,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 3.0; states[1] = 7.0; @@ -90,13 +90,13 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 5.0; rates[1] = 1000.0*9.0; rates[2] = 0.001*13.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 307290b9e..34face41a 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index 7de225f40..e640409c5 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 3 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "environment"} @@ -42,11 +42,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 3.0 states[1] = 7.0 states[2] = 11.0 @@ -56,11 +56,11 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 5.0 rates[1] = 1000.0*9.0 rates[2] = 0.001*13.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index edb43ac18..809229dc1 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 5; +const size_t ALGEBRAIC_VARIABLE_COUNT = 5; const VariableInfo VOI_INFO = {"t", "second", "main"}; @@ -72,11 +72,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -94,7 +94,7 @@ typedef struct { double *rates; double *constants; double *computedConstants; - double *algebraic; + double *algebraicVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -107,23 +107,23 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; - f[0] = constants[0]-(algebraic[0]+algebraic[1]); + f[0] = constants[0]-(algebraicVariables[0]+algebraicVariables[1]); } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[0]; + u[0] = algebraicVariables[0]; nlaSolve(objectiveFunction0, u, 1, &rfi); - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; } void objectiveFunction1(double *u, double *f, void *data) @@ -133,26 +133,26 @@ void objectiveFunction1(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[2] = u[0]; + algebraicVariables[2] = u[0]; - f[0] = algebraic[4]-(algebraic[3]+algebraic[2]); + f[0] = algebraicVariables[4]-(algebraicVariables[3]+algebraicVariables[2]); } -void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[2]; + u[0] = algebraicVariables[2]; nlaSolve(objectiveFunction1, u, 1, &rfi); - algebraic[2] = u[0]; + algebraicVariables[2] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; states[1] = 0.0; @@ -161,30 +161,30 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[2] = 20.0; constants[3] = 2.0; constants[4] = 10.0; - algebraic[0] = 0.0; - algebraic[2] = 0.0; + algebraicVariables[0] = 0.0; + algebraicVariables[2] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[1] = states[1]+constants[1]; - findRoot0(voi, states, rates, constants, computedConstants, algebraic); - rates[0] = algebraic[0]; - algebraic[3] = constants[3]*algebraic[1]; - algebraic[4] = states[0]/constants[2]; - findRoot1(voi, states, rates, constants, computedConstants, algebraic); - rates[1] = algebraic[2]/constants[4]; + algebraicVariables[1] = states[1]+constants[1]; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + rates[0] = algebraicVariables[0]; + algebraicVariables[3] = constants[3]*algebraicVariables[1]; + algebraicVariables[4] = states[0]/constants[2]; + findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); + rates[1] = algebraicVariables[2]/constants[4]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[1] = states[1]+constants[1]; - findRoot0(voi, states, rates, constants, computedConstants, algebraic); - algebraic[3] = constants[3]*algebraic[1]; - algebraic[4] = states[0]/constants[2]; - findRoot1(voi, states, rates, constants, computedConstants, algebraic); + algebraicVariables[1] = states[1]+constants[1]; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[3] = constants[3]*algebraicVariables[1]; + algebraicVariables[4] = states[0]/constants[2]; + findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 513fd0922..3251075ec 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[6]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index d853a464d..bc047295b 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 2 CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 5 +ALGEBRAIC_VARIABLE_COUNT = 5 VOI_INFO = {"name": "t", "units": "second", "component": "main"} @@ -51,8 +51,8 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT from nlasolver import nla_solve @@ -64,21 +64,21 @@ def objective_function_0(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[0] = u[0] + algebraicVariables[0] = u[0] - f[0] = constants[0]-(algebraic[0]+algebraic[1]) + f[0] = constants[0]-(algebraicVariables[0]+algebraicVariables[1]) -def find_root_0(voi, states, rates, constants, computed_constants, algebraic): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[0] + u[0] = algebraicVariables[0] - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[0] = u[0] + algebraicVariables[0] = u[0] def objective_function_1(u, f, data): @@ -87,24 +87,24 @@ def objective_function_1(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[2] = u[0] + algebraicVariables[2] = u[0] - f[0] = algebraic[4]-(algebraic[3]+algebraic[2]) + f[0] = algebraicVariables[4]-(algebraicVariables[3]+algebraicVariables[2]) -def find_root_1(voi, states, rates, constants, computed_constants, algebraic): +def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[2] + u[0] = algebraicVariables[2] - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[2] = u[0] + algebraicVariables[2] = u[0] -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 states[1] = 0.0 constants[0] = 1.0 @@ -112,27 +112,27 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic constants[2] = 20.0 constants[3] = 2.0 constants[4] = 10.0 - algebraic[0] = 0.0 - algebraic[2] = 0.0 + algebraicVariables[0] = 0.0 + algebraicVariables[2] = 0.0 def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = states[1]+constants[1] - find_root_0(voi, states, rates, constants, computed_constants, algebraic) - rates[0] = algebraic[0] - algebraic[3] = constants[3]*algebraic[1] - algebraic[4] = states[0]/constants[2] - find_root_1(voi, states, rates, constants, computed_constants, algebraic) - rates[1] = algebraic[2]/constants[4] +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[1] = states[1]+constants[1] + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + rates[0] = algebraicVariables[0] + algebraicVariables[3] = constants[3]*algebraicVariables[1] + algebraicVariables[4] = states[0]/constants[2] + find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) + rates[1] = algebraicVariables[2]/constants[4] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = states[1]+constants[1] - find_root_0(voi, states, rates, constants, computed_constants, algebraic) - algebraic[3] = constants[3]*algebraic[1] - algebraic[4] = states[0]/constants[2] - find_root_1(voi, states, rates, constants, computed_constants, algebraic) +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[1] = states[1]+constants[1] + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + algebraicVariables[3] = constants[3]*algebraicVariables[1] + algebraicVariables[4] = states[0]/constants[2] + find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 57686b9e1..7564c3950 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; const VariableInfo VOI_INFO = {"time", "second", "my_component"}; @@ -63,11 +63,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; } @@ -88,13 +88,13 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = 2.0*voi; - algebraic[1] = 3.0*algebraic[0]; + algebraicVariables[0] = 2.0*voi; + algebraicVariables[1] = 3.0*algebraicVariables[0]; } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index b5ccc8efe..785cd94aa 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[5]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index b51bbca56..7ecaeb08d 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 2 VOI_INFO = {"name": "time", "units": "second", "component": "my_component"} @@ -42,11 +42,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 @@ -54,10 +54,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = 2.0*voi - algebraic[1] = 3.0*algebraic[0] +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = 2.0*voi + algebraicVariables[1] = 3.0*algebraicVariables[0] diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index 817aa3484..a7a730710 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 33; const size_t CONSTANT_COUNT = 91; const size_t COMPUTED_CONSTANT_COUNT = 25; -const size_t ALGEBRAIC_COUNT = 101; +const size_t ALGEBRAIC_VARIABLE_COUNT = 101; const VariableInfo VOI_INFO = {"time", "second", "environment"}; @@ -310,11 +310,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -326,7 +326,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 6.226104e-5; states[1] = 5.0; @@ -483,239 +483,239 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[24] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*constants[0], 1.6951))+0.025641; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = states[1]; - algebraic[47] = ((voi > constants[66]) && (voi < constants[66]+constants[65]))?constants[64]:constants[67]; - algebraic[8] = (constants[63] >= 1.0)?algebraic[47]:states[15]; - algebraic[5] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(algebraic[0]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraic[1] = computedConstants[0]*log(constants[2]/algebraic[0]); - algebraic[6] = states[16]*computedConstants[14]*(algebraic[8]-algebraic[1])*(1.0-constants[71]); - algebraic[51] = computedConstants[0]*log((constants[2]+0.12*constants[4])/(algebraic[0]+0.12*constants[3])); - algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]); - algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]); - algebraic[7] = algebraic[52]+algebraic[53]; - algebraic[4] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[0], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[1]+110.0)/20.0), -1.0); - algebraic[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic[8]/computedConstants[0])+algebraic[0]/constants[19])+algebraic[0]/constants[18]*(1.0+algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])); - algebraic[13] = states[0]/constants[15]*exp(-constants[14]*algebraic[8]/computedConstants[0])/algebraic[20]; - algebraic[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraic[8]/computedConstants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])); - algebraic[14] = constants[5]/constants[22]*exp(constants[21]*algebraic[8]/computedConstants[0])/algebraic[21]; - algebraic[17] = exp(constants[16]*algebraic[8]/(2.0*computedConstants[0])); - algebraic[19] = algebraic[0]/constants[18]*algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])*exp(constants[16]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[20]; - algebraic[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[21]; - algebraic[9] = algebraic[18]*computedConstants[5]*(algebraic[19]+algebraic[13])+algebraic[19]*algebraic[14]*(computedConstants[5]+algebraic[17]); - algebraic[16] = algebraic[0]/(constants[13]+algebraic[0]); - algebraic[15] = exp(-constants[16]*algebraic[8]/(2.0*computedConstants[0])); - algebraic[10] = algebraic[19]*algebraic[16]*(algebraic[18]+algebraic[14])+algebraic[13]*algebraic[18]*(algebraic[16]+algebraic[15]); - algebraic[11] = algebraic[17]*algebraic[16]*(algebraic[19]+algebraic[13])+algebraic[15]*algebraic[13]*(computedConstants[5]+algebraic[17]); - algebraic[12] = algebraic[15]*computedConstants[5]*(algebraic[18]+algebraic[14])+algebraic[14]*algebraic[17]*(algebraic[16]+algebraic[15]); - algebraic[3] = (1.0-constants[12])*constants[11]*(algebraic[11]*algebraic[14]-algebraic[12]*algebraic[13])/(algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]); - rates[1] = (1.0-constants[7])*-1.0*(algebraic[7]+algebraic[6]+algebraic[5]+3.0*algebraic[4]+3.0*algebraic[3])/(1.0*(computedConstants[3]+computedConstants[2])*constants[6]); - algebraic[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])); - algebraic[25] = constants[30]/algebraic[24]; - algebraic[26] = constants[31]*algebraic[24]; - rates[4] = constants[33]*states[5]-algebraic[26]*states[0]*states[4]-(algebraic[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]); - rates[3] = algebraic[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]-(algebraic[26]*states[0]*states[3]-constants[33]*states[6]); - rates[6] = algebraic[26]*states[0]*states[3]-constants[33]*states[6]-(constants[32]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]); - rates[5] = constants[32]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]-(constants[33]*states[5]-algebraic[26]*states[0]*states[4]); - algebraic[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9]; - rates[9] = algebraic[31]; - algebraic[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10]; - rates[10] = algebraic[32]; - algebraic[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11]; - rates[11] = algebraic[33]; - algebraic[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12]; - rates[12] = algebraic[34]; - algebraic[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13]; - rates[13] = algebraic[35]; - algebraic[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14]; - rates[14] = algebraic[36]; - algebraic[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])); - algebraic[28] = (states[0]-states[7])/constants[35]; - rates[7] = 1.0*(algebraic[28]*computedConstants[2]-algebraic[29]*computedConstants[8])/computedConstants[3]-(constants[52]*algebraic[34]+constants[50]*algebraic[31]+constants[51]*algebraic[32]); - algebraic[22] = constants[25]*states[3]*(states[2]-states[0]); - algebraic[37] = 2.0*constants[84]*algebraic[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computedConstants[0]))*states[25]*states[24]; - algebraic[38] = 2.0*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - rates[0] = algebraic[22]*computedConstants[9]/computedConstants[2]-((algebraic[38]+algebraic[37]-2.0*algebraic[3])/(2.0*constants[6]*computedConstants[2])+algebraic[28]+constants[52]*algebraic[35]); - algebraic[30] = (states[8]-states[2])/constants[38]; - rates[8] = algebraic[29]-algebraic[30]*computedConstants[9]/computedConstants[8]; - rates[2] = algebraic[30]-(algebraic[22]+constants[53]*algebraic[36]); - algebraic[39] = constants[76]*states[20]*states[19]*(algebraic[8]-computedConstants[1]); - algebraic[40] = (constants[0] > 0.0)?constants[90]*constants[89]*(algebraic[8]-computedConstants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32]:0.0; - algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraic[41] = (algebraic[38]+algebraic[67]+algebraic[5])*(1.0-computedConstants[19])*1.0*computedConstants[18]; - algebraic[42] = constants[86]*(algebraic[8]-computedConstants[1])*states[27]*states[26]; - algebraic[93] = computedConstants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraic[0])); - algebraic[43] = computedConstants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0); - algebraic[44] = constants[87]*(algebraic[8]-computedConstants[1])*(0.9*states[30]+0.1*states[29])*states[28]; - algebraic[48] = states[16]*computedConstants[15]*(algebraic[8]-computedConstants[1])*(1.0-constants[71]); - algebraic[45] = algebraic[6]+algebraic[48]; - algebraic[46] = algebraic[45]+algebraic[44]+algebraic[43]+algebraic[42]+algebraic[4]+algebraic[3]+algebraic[7]+algebraic[41]+algebraic[37]+algebraic[40]+algebraic[39]; - rates[15] = -algebraic[46]/constants[60]; - algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17])/(exp(0.066*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17]))-1.0)+0.1*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17]))))-0.054; - algebraic[50] = (algebraic[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraic[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); - rates[16] = (algebraic[50]-states[16])/algebraic[49]; - algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)); - algebraic[55] = algebraic[8]+41.0; - algebraic[56] = (fabs(algebraic[55]) < constants[75])?2000.0:200.0*algebraic[55]/(1.0-exp(-0.1*algebraic[55])); - algebraic[58] = 1.0/(algebraic[56]+algebraic[57]); - algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)); - rates[18] = (algebraic[54]-states[18])/algebraic[58]; - algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0); - algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)); - algebraic[62] = 1.0/(algebraic[60]+algebraic[61]); - algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)); - rates[17] = (algebraic[59]-states[17])/algebraic[62]; - algebraic[63] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005; - algebraic[64] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)); - rates[20] = (algebraic[64]-states[20])/algebraic[63]; - algebraic[65] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05; - algebraic[66] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)); - rates[19] = (algebraic[66]-states[19])/algebraic[65]; - algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[79]-computedConstants[20])/(constants[78]*(1.0+computedConstants[21]/100.0)))); - algebraic[73] = (algebraic[8] == -1.8)?-1.80001:algebraic[8]; - algebraic[69] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0); - algebraic[72] = (algebraic[8] == -41.8)?-41.80001:(algebraic[8] == 0.0)?0.0:(algebraic[8] == -6.8)?-6.80001:algebraic[8]; - algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0); - algebraic[71] = 0.001/(algebraic[70]+algebraic[69]); - rates[23] = (algebraic[68]-states[23])/algebraic[71]; - algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))); - algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[81])/(5.3+constants[80]))); - rates[22] = (algebraic[74]-states[22])/algebraic[75]; - algebraic[76] = constants[82]/(constants[82]+states[0]); - algebraic[77] = 0.001*algebraic[76]/constants[83]; - rates[21] = (algebraic[76]-states[21])/algebraic[77]; - algebraic[79] = 0.001/(1.068*exp((algebraic[8]+38.3)/30.0)+1.068*exp(-(algebraic[8]+38.3)/30.0)); - algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)); - rates[25] = (algebraic[78]-states[25])/algebraic[79]; - algebraic[81] = 1.0/(16.67*exp(-(algebraic[8]+75.0)/83.3)+16.67*exp((algebraic[8]+75.0)/15.38))+constants[85]; - algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)); - rates[24] = (algebraic[80]-states[24])/algebraic[81]; - algebraic[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[8]+44.0))+0.065*exp(0.1*(algebraic[8]+45.93)))+10.1); - algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)); - rates[27] = (algebraic[82]-states[27])/algebraic[83]; - algebraic[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[8]+30.61))+0.369*exp(-0.12*(algebraic[8]+23.84)))+2.98); - algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)); - rates[26] = (algebraic[84]-states[26])/algebraic[85]; - algebraic[89] = 0.84655354/(4.2*exp(algebraic[8]/17.0)+0.15*exp(-algebraic[8]/21.6)); - algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)); - rates[29] = (algebraic[88]-states[29])/algebraic[89]; - algebraic[90] = 1.0/(30.0*exp(algebraic[8]/10.0)+exp(-algebraic[8]/12.0)); - rates[30] = (algebraic[88]-states[30])/algebraic[90]; - algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)); - algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)); - rates[28] = (algebraic[92]-states[28])/algebraic[91]; - algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computedConstants[23])/10.7071))); - algebraic[95] = 1.0*exp(-(algebraic[8]-computedConstants[23]-5.0)/25.0); - algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computedConstants[23])/3.0)); - algebraic[97] = 1.0/(algebraic[96]+algebraic[95]); - rates[31] = (algebraic[94]-states[31])/algebraic[97]; - algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)); - algebraic[100] = 1.0/(computedConstants[24]+algebraic[98]); - algebraic[99] = computedConstants[24]/(computedConstants[24]+algebraic[98]); - rates[32] = (algebraic[99]-states[32])/algebraic[100]; + algebraicVariables[0] = states[1]; + algebraicVariables[47] = ((voi > constants[66]) && (voi < constants[66]+constants[65]))?constants[64]:constants[67]; + algebraicVariables[8] = (constants[63] >= 1.0)?algebraicVariables[47]:states[15]; + algebraicVariables[5] = 0.0000185*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0])))*(algebraicVariables[0]-constants[2]*exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraicVariables[1] = computedConstants[0]*log(constants[2]/algebraicVariables[0]); + algebraicVariables[6] = states[16]*computedConstants[14]*(algebraicVariables[8]-algebraicVariables[1])*(1.0-constants[71]); + algebraicVariables[51] = computedConstants[0]*log((constants[2]+0.12*constants[4])/(algebraicVariables[0]+0.12*constants[3])); + algebraicVariables[53] = constants[74]*pow(states[18], 3.0)*(algebraicVariables[8]-algebraicVariables[51]); + algebraicVariables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraicVariables[8]-algebraicVariables[51]); + algebraicVariables[7] = algebraicVariables[52]+algebraicVariables[53]; + algebraicVariables[4] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraicVariables[0], 1.3), -1.0)*pow(1.0+exp(-(algebraicVariables[8]-algebraicVariables[1]+110.0)/20.0), -1.0); + algebraicVariables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraicVariables[8]/computedConstants[0])+algebraicVariables[0]/constants[19])+algebraicVariables[0]/constants[18]*(1.0+algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])); + algebraicVariables[13] = states[0]/constants[15]*exp(-constants[14]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[20]; + algebraicVariables[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraicVariables[8]/computedConstants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])); + algebraicVariables[14] = constants[5]/constants[22]*exp(constants[21]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[21]; + algebraicVariables[17] = exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); + algebraicVariables[19] = algebraicVariables[0]/constants[18]*algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])*exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0]))/algebraicVariables[20]; + algebraicVariables[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraicVariables[8]/(2.0*computedConstants[0]))/algebraicVariables[21]; + algebraicVariables[9] = algebraicVariables[18]*computedConstants[5]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[19]*algebraicVariables[14]*(computedConstants[5]+algebraicVariables[17]); + algebraicVariables[16] = algebraicVariables[0]/(constants[13]+algebraicVariables[0]); + algebraicVariables[15] = exp(-constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); + algebraicVariables[10] = algebraicVariables[19]*algebraicVariables[16]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[13]*algebraicVariables[18]*(algebraicVariables[16]+algebraicVariables[15]); + algebraicVariables[11] = algebraicVariables[17]*algebraicVariables[16]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[15]*algebraicVariables[13]*(computedConstants[5]+algebraicVariables[17]); + algebraicVariables[12] = algebraicVariables[15]*computedConstants[5]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[14]*algebraicVariables[17]*(algebraicVariables[16]+algebraicVariables[15]); + algebraicVariables[3] = (1.0-constants[12])*constants[11]*(algebraicVariables[11]*algebraicVariables[14]-algebraicVariables[12]*algebraicVariables[13])/(algebraicVariables[12]+algebraicVariables[11]+algebraicVariables[10]+algebraicVariables[9]); + rates[1] = (1.0-constants[7])*-1.0*(algebraicVariables[7]+algebraicVariables[6]+algebraicVariables[5]+3.0*algebraicVariables[4]+3.0*algebraicVariables[3])/(1.0*(computedConstants[3]+computedConstants[2])*constants[6]); + algebraicVariables[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])); + algebraicVariables[25] = constants[30]/algebraicVariables[24]; + algebraicVariables[26] = constants[31]*algebraicVariables[24]; + rates[4] = constants[33]*states[5]-algebraicVariables[26]*states[0]*states[4]-(algebraicVariables[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]); + rates[3] = algebraicVariables[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]-(algebraicVariables[26]*states[0]*states[3]-constants[33]*states[6]); + rates[6] = algebraicVariables[26]*states[0]*states[3]-constants[33]*states[6]-(constants[32]*states[6]-algebraicVariables[25]*pow(states[0], 2.0)*states[5]); + rates[5] = constants[32]*states[6]-algebraicVariables[25]*pow(states[0], 2.0)*states[5]-(constants[33]*states[5]-algebraicVariables[26]*states[0]*states[4]); + algebraicVariables[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9]; + rates[9] = algebraicVariables[31]; + algebraicVariables[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10]; + rates[10] = algebraicVariables[32]; + algebraicVariables[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11]; + rates[11] = algebraicVariables[33]; + algebraicVariables[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12]; + rates[12] = algebraicVariables[34]; + algebraicVariables[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13]; + rates[13] = algebraicVariables[35]; + algebraicVariables[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14]; + rates[14] = algebraicVariables[36]; + algebraicVariables[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])); + algebraicVariables[28] = (states[0]-states[7])/constants[35]; + rates[7] = 1.0*(algebraicVariables[28]*computedConstants[2]-algebraicVariables[29]*computedConstants[8])/computedConstants[3]-(constants[52]*algebraicVariables[34]+constants[50]*algebraicVariables[31]+constants[51]*algebraicVariables[32]); + algebraicVariables[22] = constants[25]*states[3]*(states[2]-states[0]); + algebraicVariables[37] = 2.0*constants[84]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraicVariables[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraicVariables[8]/computedConstants[0]))*states[25]*states[24]; + algebraicVariables[38] = 2.0*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + rates[0] = algebraicVariables[22]*computedConstants[9]/computedConstants[2]-((algebraicVariables[38]+algebraicVariables[37]-2.0*algebraicVariables[3])/(2.0*constants[6]*computedConstants[2])+algebraicVariables[28]+constants[52]*algebraicVariables[35]); + algebraicVariables[30] = (states[8]-states[2])/constants[38]; + rates[8] = algebraicVariables[29]-algebraicVariables[30]*computedConstants[9]/computedConstants[8]; + rates[2] = algebraicVariables[30]-(algebraicVariables[22]+constants[53]*algebraicVariables[36]); + algebraicVariables[39] = constants[76]*states[20]*states[19]*(algebraicVariables[8]-computedConstants[1]); + algebraicVariables[40] = (constants[0] > 0.0)?constants[90]*constants[89]*(algebraicVariables[8]-computedConstants[1])*(1.0+exp((algebraicVariables[8]+20.0)/20.0))*states[32]:0.0; + algebraicVariables[67] = 0.000365*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraicVariables[41] = (algebraicVariables[38]+algebraicVariables[67]+algebraicVariables[5])*(1.0-computedConstants[19])*1.0*computedConstants[18]; + algebraicVariables[42] = constants[86]*(algebraicVariables[8]-computedConstants[1])*states[27]*states[26]; + algebraicVariables[93] = computedConstants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraicVariables[0])); + algebraicVariables[43] = computedConstants[22]*(algebraicVariables[8]-algebraicVariables[93])*pow(states[31], 2.0); + algebraicVariables[44] = constants[87]*(algebraicVariables[8]-computedConstants[1])*(0.9*states[30]+0.1*states[29])*states[28]; + algebraicVariables[48] = states[16]*computedConstants[15]*(algebraicVariables[8]-computedConstants[1])*(1.0-constants[71]); + algebraicVariables[45] = algebraicVariables[6]+algebraicVariables[48]; + algebraicVariables[46] = algebraicVariables[45]+algebraicVariables[44]+algebraicVariables[43]+algebraicVariables[42]+algebraicVariables[4]+algebraicVariables[3]+algebraicVariables[7]+algebraicVariables[41]+algebraicVariables[37]+algebraicVariables[40]+algebraicVariables[39]; + rates[15] = -algebraicVariables[46]/constants[60]; + algebraicVariables[49] = 1.0/(0.36*(algebraicVariables[8]+148.8-computedConstants[16]-computedConstants[17])/(exp(0.066*(algebraicVariables[8]+148.8-computedConstants[16]-computedConstants[17]))-1.0)+0.1*(algebraicVariables[8]+87.3-computedConstants[16]-computedConstants[17])/(1.0-exp(-0.2*(algebraicVariables[8]+87.3-computedConstants[16]-computedConstants[17]))))-0.054; + algebraicVariables[50] = (algebraicVariables[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraicVariables[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraicVariables[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); + rates[16] = (algebraicVariables[50]-states[16])/algebraicVariables[49]; + algebraicVariables[57] = 8000.0*exp(-0.056*(algebraicVariables[8]+66.0)); + algebraicVariables[55] = algebraicVariables[8]+41.0; + algebraicVariables[56] = (fabs(algebraicVariables[55]) < constants[75])?2000.0:200.0*algebraicVariables[55]/(1.0-exp(-0.1*algebraicVariables[55])); + algebraicVariables[58] = 1.0/(algebraicVariables[56]+algebraicVariables[57]); + algebraicVariables[54] = 1.0/(1.0+exp(-(algebraicVariables[8]+42.0504)/8.3106)); + rates[18] = (algebraicVariables[54]-states[18])/algebraicVariables[58]; + algebraicVariables[61] = 2000.0/(320.0*exp(-0.1*(algebraicVariables[8]+75.0))+1.0); + algebraicVariables[60] = 20.0*exp(-0.125*(algebraicVariables[8]+75.0)); + algebraicVariables[62] = 1.0/(algebraicVariables[60]+algebraicVariables[61]); + algebraicVariables[59] = 1.0/(1.0+exp((algebraicVariables[8]+69.804)/4.4565)); + rates[17] = (algebraicVariables[59]-states[17])/algebraicVariables[62]; + algebraicVariables[63] = 0.009/(1.0+exp((algebraicVariables[8]+5.0)/12.0))+0.0005; + algebraicVariables[64] = 1.0/(1.0+exp((algebraicVariables[8]+6.0)/-8.6)); + rates[20] = (algebraicVariables[64]-states[20])/algebraicVariables[63]; + algebraicVariables[65] = 0.59/(1.0+exp((algebraicVariables[8]+60.0)/10.0))+3.05; + algebraicVariables[66] = 1.0/(1.0+exp((algebraicVariables[8]+7.5)/10.0)); + rates[19] = (algebraicVariables[66]-states[19])/algebraicVariables[65]; + algebraicVariables[68] = 1.0/(1.0+exp(-(algebraicVariables[8]-constants[79]-computedConstants[20])/(constants[78]*(1.0+computedConstants[21]/100.0)))); + algebraicVariables[73] = (algebraicVariables[8] == -1.8)?-1.80001:algebraicVariables[8]; + algebraicVariables[69] = 0.01143*(algebraicVariables[73]+1.8)/(exp((algebraicVariables[73]+1.8)/2.5)-1.0); + algebraicVariables[72] = (algebraicVariables[8] == -41.8)?-41.80001:(algebraicVariables[8] == 0.0)?0.0:(algebraicVariables[8] == -6.8)?-6.80001:algebraicVariables[8]; + algebraicVariables[70] = -0.02839*(algebraicVariables[72]+41.8)/(exp(-(algebraicVariables[72]+41.8)/2.5)-1.0)-0.0849*(algebraicVariables[72]+6.8)/(exp(-(algebraicVariables[72]+6.8)/4.8)-1.0); + algebraicVariables[71] = 0.001/(algebraicVariables[70]+algebraicVariables[69]); + rates[23] = (algebraicVariables[68]-states[23])/algebraicVariables[71]; + algebraicVariables[75] = 0.001*(44.3+230.0*exp(-pow((algebraicVariables[8]+36.0)/10.0, 2.0))); + algebraicVariables[74] = 1.0/(1.0+exp((algebraicVariables[8]+37.4+constants[81])/(5.3+constants[80]))); + rates[22] = (algebraicVariables[74]-states[22])/algebraicVariables[75]; + algebraicVariables[76] = constants[82]/(constants[82]+states[0]); + algebraicVariables[77] = 0.001*algebraicVariables[76]/constants[83]; + rates[21] = (algebraicVariables[76]-states[21])/algebraicVariables[77]; + algebraicVariables[79] = 0.001/(1.068*exp((algebraicVariables[8]+38.3)/30.0)+1.068*exp(-(algebraicVariables[8]+38.3)/30.0)); + algebraicVariables[78] = 1.0/(1.0+exp(-(algebraicVariables[8]+38.3)/5.5)); + rates[25] = (algebraicVariables[78]-states[25])/algebraicVariables[79]; + algebraicVariables[81] = 1.0/(16.67*exp(-(algebraicVariables[8]+75.0)/83.3)+16.67*exp((algebraicVariables[8]+75.0)/15.38))+constants[85]; + algebraicVariables[80] = 1.0/(1.0+exp((algebraicVariables[8]+58.7)/3.8)); + rates[24] = (algebraicVariables[80]-states[24])/algebraicVariables[81]; + algebraicVariables[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraicVariables[8]+44.0))+0.065*exp(0.1*(algebraicVariables[8]+45.93)))+10.1); + algebraicVariables[82] = 1.0/(1.0+exp((algebraicVariables[8]+49.0)/13.0)); + rates[27] = (algebraicVariables[82]-states[27])/algebraicVariables[83]; + algebraicVariables[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraicVariables[8]+30.61))+0.369*exp(-0.12*(algebraicVariables[8]+23.84)))+2.98); + algebraicVariables[84] = 1.0/(1.0+exp(-(algebraicVariables[8]-19.3)/15.0)); + rates[26] = (algebraicVariables[84]-states[26])/algebraicVariables[85]; + algebraicVariables[89] = 0.84655354/(4.2*exp(algebraicVariables[8]/17.0)+0.15*exp(-algebraicVariables[8]/21.6)); + algebraicVariables[88] = 1.0/(1.0+exp(-(algebraicVariables[8]+10.0144)/7.6607)); + rates[29] = (algebraicVariables[88]-states[29])/algebraicVariables[89]; + algebraicVariables[90] = 1.0/(30.0*exp(algebraicVariables[8]/10.0)+exp(-algebraicVariables[8]/12.0)); + rates[30] = (algebraicVariables[88]-states[30])/algebraicVariables[90]; + algebraicVariables[91] = 1.0/(100.0*exp(-algebraicVariables[8]/54.645)+656.0*exp(algebraicVariables[8]/106.157)); + algebraicVariables[92] = 1.0/(1.0+exp((algebraicVariables[8]+28.6)/17.1)); + rates[28] = (algebraicVariables[92]-states[28])/algebraicVariables[91]; + algebraicVariables[94] = sqrt(1.0/(1.0+exp(-(algebraicVariables[8]+0.6383-computedConstants[23])/10.7071))); + algebraicVariables[95] = 1.0*exp(-(algebraicVariables[8]-computedConstants[23]-5.0)/25.0); + algebraicVariables[96] = 28.0/(1.0+exp(-(algebraicVariables[8]-40.0-computedConstants[23])/3.0)); + algebraicVariables[97] = 1.0/(algebraicVariables[96]+algebraicVariables[95]); + rates[31] = (algebraicVariables[94]-states[31])/algebraicVariables[97]; + algebraicVariables[98] = 10.0*exp(0.0133*(algebraicVariables[8]+40.0)); + algebraicVariables[100] = 1.0/(computedConstants[24]+algebraicVariables[98]); + algebraicVariables[99] = computedConstants[24]/(computedConstants[24]+algebraicVariables[98]); + rates[32] = (algebraicVariables[99]-states[32])/algebraicVariables[100]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = states[1]; - algebraic[1] = computedConstants[0]*log(constants[2]/algebraic[0]); - algebraic[2] = 0.5*computedConstants[0]*log(constants[5]/states[0]); - algebraic[8] = (constants[63] >= 1.0)?algebraic[47]:states[15]; - algebraic[4] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[0], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[1]+110.0)/20.0), -1.0); - algebraic[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic[8]/computedConstants[0])+algebraic[0]/constants[19])+algebraic[0]/constants[18]*(1.0+algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])); - algebraic[13] = states[0]/constants[15]*exp(-constants[14]*algebraic[8]/computedConstants[0])/algebraic[20]; - algebraic[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraic[8]/computedConstants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])); - algebraic[14] = constants[5]/constants[22]*exp(constants[21]*algebraic[8]/computedConstants[0])/algebraic[21]; - algebraic[17] = exp(constants[16]*algebraic[8]/(2.0*computedConstants[0])); - algebraic[19] = algebraic[0]/constants[18]*algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])*exp(constants[16]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[20]; - algebraic[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraic[8]/(2.0*computedConstants[0]))/algebraic[21]; - algebraic[9] = algebraic[18]*computedConstants[5]*(algebraic[19]+algebraic[13])+algebraic[19]*algebraic[14]*(computedConstants[5]+algebraic[17]); - algebraic[16] = algebraic[0]/(constants[13]+algebraic[0]); - algebraic[15] = exp(-constants[16]*algebraic[8]/(2.0*computedConstants[0])); - algebraic[10] = algebraic[19]*algebraic[16]*(algebraic[18]+algebraic[14])+algebraic[13]*algebraic[18]*(algebraic[16]+algebraic[15]); - algebraic[11] = algebraic[17]*algebraic[16]*(algebraic[19]+algebraic[13])+algebraic[15]*algebraic[13]*(computedConstants[5]+algebraic[17]); - algebraic[12] = algebraic[15]*computedConstants[5]*(algebraic[18]+algebraic[14])+algebraic[14]*algebraic[17]*(algebraic[16]+algebraic[15]); - algebraic[3] = (1.0-constants[12])*constants[11]*(algebraic[11]*algebraic[14]-algebraic[12]*algebraic[13])/(algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]); - algebraic[22] = constants[25]*states[3]*(states[2]-states[0]); - algebraic[23] = states[2]-states[0]; - algebraic[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])); - algebraic[25] = constants[30]/algebraic[24]; - algebraic[26] = constants[31]*algebraic[24]; - algebraic[27] = states[4]+states[3]+states[6]+states[5]; - algebraic[28] = (states[0]-states[7])/constants[35]; - algebraic[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])); - algebraic[30] = (states[8]-states[2])/constants[38]; - algebraic[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9]; - algebraic[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10]; - algebraic[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11]; - algebraic[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12]; - algebraic[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13]; - algebraic[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14]; - algebraic[39] = constants[76]*states[20]*states[19]*(algebraic[8]-computedConstants[1]); - algebraic[40] = (constants[0] > 0.0)?constants[90]*constants[89]*(algebraic[8]-computedConstants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32]:0.0; - algebraic[37] = 2.0*constants[84]*algebraic[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computedConstants[0]))*states[25]*states[24]; - algebraic[5] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(algebraic[0]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computedConstants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraic[38] = 2.0*constants[77]*(algebraic[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraic[41] = (algebraic[38]+algebraic[67]+algebraic[5])*(1.0-computedConstants[19])*1.0*computedConstants[18]; - algebraic[51] = computedConstants[0]*log((constants[2]+0.12*constants[4])/(algebraic[0]+0.12*constants[3])); - algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]); - algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]); - algebraic[7] = algebraic[52]+algebraic[53]; - algebraic[42] = constants[86]*(algebraic[8]-computedConstants[1])*states[27]*states[26]; - algebraic[93] = computedConstants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraic[0])); - algebraic[43] = computedConstants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0); - algebraic[44] = constants[87]*(algebraic[8]-computedConstants[1])*(0.9*states[30]+0.1*states[29])*states[28]; - algebraic[48] = states[16]*computedConstants[15]*(algebraic[8]-computedConstants[1])*(1.0-constants[71]); - algebraic[6] = states[16]*computedConstants[14]*(algebraic[8]-algebraic[1])*(1.0-constants[71]); - algebraic[45] = algebraic[6]+algebraic[48]; - algebraic[46] = algebraic[45]+algebraic[44]+algebraic[43]+algebraic[42]+algebraic[4]+algebraic[3]+algebraic[7]+algebraic[41]+algebraic[37]+algebraic[40]+algebraic[39]; - algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17])/(exp(0.066*(algebraic[8]+148.8-computedConstants[16]-computedConstants[17]))-1.0)+0.1*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computedConstants[16]-computedConstants[17]))))-0.054; - algebraic[50] = (algebraic[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraic[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); - algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)); - algebraic[55] = algebraic[8]+41.0; - algebraic[56] = (fabs(algebraic[55]) < constants[75])?2000.0:200.0*algebraic[55]/(1.0-exp(-0.1*algebraic[55])); - algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)); - algebraic[58] = 1.0/(algebraic[56]+algebraic[57]); - algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)); - algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)); - algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0); - algebraic[62] = 1.0/(algebraic[60]+algebraic[61]); - algebraic[64] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)); - algebraic[63] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005; - algebraic[66] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)); - algebraic[65] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05; - algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[79]-computedConstants[20])/(constants[78]*(1.0+computedConstants[21]/100.0)))); - algebraic[73] = (algebraic[8] == -1.8)?-1.80001:algebraic[8]; - algebraic[69] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0); - algebraic[72] = (algebraic[8] == -41.8)?-41.80001:(algebraic[8] == 0.0)?0.0:(algebraic[8] == -6.8)?-6.80001:algebraic[8]; - algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0); - algebraic[71] = 0.001/(algebraic[70]+algebraic[69]); - algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[81])/(5.3+constants[80]))); - algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))); - algebraic[76] = constants[82]/(constants[82]+states[0]); - algebraic[77] = 0.001*algebraic[76]/constants[83]; - algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)); - algebraic[79] = 0.001/(1.068*exp((algebraic[8]+38.3)/30.0)+1.068*exp(-(algebraic[8]+38.3)/30.0)); - algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)); - algebraic[81] = 1.0/(16.67*exp(-(algebraic[8]+75.0)/83.3)+16.67*exp((algebraic[8]+75.0)/15.38))+constants[85]; - algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)); - algebraic[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[8]+44.0))+0.065*exp(0.1*(algebraic[8]+45.93)))+10.1); - algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)); - algebraic[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[8]+30.61))+0.369*exp(-0.12*(algebraic[8]+23.84)))+2.98); - algebraic[86] = 1.0/(1.0+exp(-(algebraic[8]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraic[8]/11.9)+0.96*exp(-algebraic[8]/18.5))); - algebraic[87] = 4.0*((37.2*exp(algebraic[8]/15.9)+0.96*exp(-algebraic[8]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraic[8]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraic[8]/15.9)+0.96*exp(-algebraic[8]/22.5)))); - algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)); - algebraic[89] = 0.84655354/(4.2*exp(algebraic[8]/17.0)+0.15*exp(-algebraic[8]/21.6)); - algebraic[90] = 1.0/(30.0*exp(algebraic[8]/10.0)+exp(-algebraic[8]/12.0)); - algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)); - algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)); - algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computedConstants[23])/10.7071))); - algebraic[95] = 1.0*exp(-(algebraic[8]-computedConstants[23]-5.0)/25.0); - algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computedConstants[23])/3.0)); - algebraic[97] = 1.0/(algebraic[96]+algebraic[95]); - algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)); - algebraic[99] = computedConstants[24]/(computedConstants[24]+algebraic[98]); - algebraic[100] = 1.0/(computedConstants[24]+algebraic[98]); + algebraicVariables[0] = states[1]; + algebraicVariables[1] = computedConstants[0]*log(constants[2]/algebraicVariables[0]); + algebraicVariables[2] = 0.5*computedConstants[0]*log(constants[5]/states[0]); + algebraicVariables[8] = (constants[63] >= 1.0)?algebraicVariables[47]:states[15]; + algebraicVariables[4] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraicVariables[0], 1.3), -1.0)*pow(1.0+exp(-(algebraicVariables[8]-algebraicVariables[1]+110.0)/20.0), -1.0); + algebraicVariables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraicVariables[8]/computedConstants[0])+algebraicVariables[0]/constants[19])+algebraicVariables[0]/constants[18]*(1.0+algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])); + algebraicVariables[13] = states[0]/constants[15]*exp(-constants[14]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[20]; + algebraicVariables[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraicVariables[8]/computedConstants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])); + algebraicVariables[14] = constants[5]/constants[22]*exp(constants[21]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[21]; + algebraicVariables[17] = exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); + algebraicVariables[19] = algebraicVariables[0]/constants[18]*algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])*exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0]))/algebraicVariables[20]; + algebraicVariables[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraicVariables[8]/(2.0*computedConstants[0]))/algebraicVariables[21]; + algebraicVariables[9] = algebraicVariables[18]*computedConstants[5]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[19]*algebraicVariables[14]*(computedConstants[5]+algebraicVariables[17]); + algebraicVariables[16] = algebraicVariables[0]/(constants[13]+algebraicVariables[0]); + algebraicVariables[15] = exp(-constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); + algebraicVariables[10] = algebraicVariables[19]*algebraicVariables[16]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[13]*algebraicVariables[18]*(algebraicVariables[16]+algebraicVariables[15]); + algebraicVariables[11] = algebraicVariables[17]*algebraicVariables[16]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[15]*algebraicVariables[13]*(computedConstants[5]+algebraicVariables[17]); + algebraicVariables[12] = algebraicVariables[15]*computedConstants[5]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[14]*algebraicVariables[17]*(algebraicVariables[16]+algebraicVariables[15]); + algebraicVariables[3] = (1.0-constants[12])*constants[11]*(algebraicVariables[11]*algebraicVariables[14]-algebraicVariables[12]*algebraicVariables[13])/(algebraicVariables[12]+algebraicVariables[11]+algebraicVariables[10]+algebraicVariables[9]); + algebraicVariables[22] = constants[25]*states[3]*(states[2]-states[0]); + algebraicVariables[23] = states[2]-states[0]; + algebraicVariables[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])); + algebraicVariables[25] = constants[30]/algebraicVariables[24]; + algebraicVariables[26] = constants[31]*algebraicVariables[24]; + algebraicVariables[27] = states[4]+states[3]+states[6]+states[5]; + algebraicVariables[28] = (states[0]-states[7])/constants[35]; + algebraicVariables[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])); + algebraicVariables[30] = (states[8]-states[2])/constants[38]; + algebraicVariables[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9]; + algebraicVariables[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10]; + algebraicVariables[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11]; + algebraicVariables[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12]; + algebraicVariables[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13]; + algebraicVariables[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14]; + algebraicVariables[39] = constants[76]*states[20]*states[19]*(algebraicVariables[8]-computedConstants[1]); + algebraicVariables[40] = (constants[0] > 0.0)?constants[90]*constants[89]*(algebraicVariables[8]-computedConstants[1])*(1.0+exp((algebraicVariables[8]+20.0)/20.0))*states[32]:0.0; + algebraicVariables[37] = 2.0*constants[84]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraicVariables[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraicVariables[8]/computedConstants[0]))*states[25]*states[24]; + algebraicVariables[5] = 0.0000185*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0])))*(algebraicVariables[0]-constants[2]*exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraicVariables[67] = 0.000365*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraicVariables[38] = 2.0*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; + algebraicVariables[41] = (algebraicVariables[38]+algebraicVariables[67]+algebraicVariables[5])*(1.0-computedConstants[19])*1.0*computedConstants[18]; + algebraicVariables[51] = computedConstants[0]*log((constants[2]+0.12*constants[4])/(algebraicVariables[0]+0.12*constants[3])); + algebraicVariables[53] = constants[74]*pow(states[18], 3.0)*(algebraicVariables[8]-algebraicVariables[51]); + algebraicVariables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraicVariables[8]-algebraicVariables[51]); + algebraicVariables[7] = algebraicVariables[52]+algebraicVariables[53]; + algebraicVariables[42] = constants[86]*(algebraicVariables[8]-computedConstants[1])*states[27]*states[26]; + algebraicVariables[93] = computedConstants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraicVariables[0])); + algebraicVariables[43] = computedConstants[22]*(algebraicVariables[8]-algebraicVariables[93])*pow(states[31], 2.0); + algebraicVariables[44] = constants[87]*(algebraicVariables[8]-computedConstants[1])*(0.9*states[30]+0.1*states[29])*states[28]; + algebraicVariables[48] = states[16]*computedConstants[15]*(algebraicVariables[8]-computedConstants[1])*(1.0-constants[71]); + algebraicVariables[6] = states[16]*computedConstants[14]*(algebraicVariables[8]-algebraicVariables[1])*(1.0-constants[71]); + algebraicVariables[45] = algebraicVariables[6]+algebraicVariables[48]; + algebraicVariables[46] = algebraicVariables[45]+algebraicVariables[44]+algebraicVariables[43]+algebraicVariables[42]+algebraicVariables[4]+algebraicVariables[3]+algebraicVariables[7]+algebraicVariables[41]+algebraicVariables[37]+algebraicVariables[40]+algebraicVariables[39]; + algebraicVariables[49] = 1.0/(0.36*(algebraicVariables[8]+148.8-computedConstants[16]-computedConstants[17])/(exp(0.066*(algebraicVariables[8]+148.8-computedConstants[16]-computedConstants[17]))-1.0)+0.1*(algebraicVariables[8]+87.3-computedConstants[16]-computedConstants[17])/(1.0-exp(-0.2*(algebraicVariables[8]+87.3-computedConstants[16]-computedConstants[17]))))-0.054; + algebraicVariables[50] = (algebraicVariables[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraicVariables[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraicVariables[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); + algebraicVariables[54] = 1.0/(1.0+exp(-(algebraicVariables[8]+42.0504)/8.3106)); + algebraicVariables[55] = algebraicVariables[8]+41.0; + algebraicVariables[56] = (fabs(algebraicVariables[55]) < constants[75])?2000.0:200.0*algebraicVariables[55]/(1.0-exp(-0.1*algebraicVariables[55])); + algebraicVariables[57] = 8000.0*exp(-0.056*(algebraicVariables[8]+66.0)); + algebraicVariables[58] = 1.0/(algebraicVariables[56]+algebraicVariables[57]); + algebraicVariables[59] = 1.0/(1.0+exp((algebraicVariables[8]+69.804)/4.4565)); + algebraicVariables[60] = 20.0*exp(-0.125*(algebraicVariables[8]+75.0)); + algebraicVariables[61] = 2000.0/(320.0*exp(-0.1*(algebraicVariables[8]+75.0))+1.0); + algebraicVariables[62] = 1.0/(algebraicVariables[60]+algebraicVariables[61]); + algebraicVariables[64] = 1.0/(1.0+exp((algebraicVariables[8]+6.0)/-8.6)); + algebraicVariables[63] = 0.009/(1.0+exp((algebraicVariables[8]+5.0)/12.0))+0.0005; + algebraicVariables[66] = 1.0/(1.0+exp((algebraicVariables[8]+7.5)/10.0)); + algebraicVariables[65] = 0.59/(1.0+exp((algebraicVariables[8]+60.0)/10.0))+3.05; + algebraicVariables[68] = 1.0/(1.0+exp(-(algebraicVariables[8]-constants[79]-computedConstants[20])/(constants[78]*(1.0+computedConstants[21]/100.0)))); + algebraicVariables[73] = (algebraicVariables[8] == -1.8)?-1.80001:algebraicVariables[8]; + algebraicVariables[69] = 0.01143*(algebraicVariables[73]+1.8)/(exp((algebraicVariables[73]+1.8)/2.5)-1.0); + algebraicVariables[72] = (algebraicVariables[8] == -41.8)?-41.80001:(algebraicVariables[8] == 0.0)?0.0:(algebraicVariables[8] == -6.8)?-6.80001:algebraicVariables[8]; + algebraicVariables[70] = -0.02839*(algebraicVariables[72]+41.8)/(exp(-(algebraicVariables[72]+41.8)/2.5)-1.0)-0.0849*(algebraicVariables[72]+6.8)/(exp(-(algebraicVariables[72]+6.8)/4.8)-1.0); + algebraicVariables[71] = 0.001/(algebraicVariables[70]+algebraicVariables[69]); + algebraicVariables[74] = 1.0/(1.0+exp((algebraicVariables[8]+37.4+constants[81])/(5.3+constants[80]))); + algebraicVariables[75] = 0.001*(44.3+230.0*exp(-pow((algebraicVariables[8]+36.0)/10.0, 2.0))); + algebraicVariables[76] = constants[82]/(constants[82]+states[0]); + algebraicVariables[77] = 0.001*algebraicVariables[76]/constants[83]; + algebraicVariables[78] = 1.0/(1.0+exp(-(algebraicVariables[8]+38.3)/5.5)); + algebraicVariables[79] = 0.001/(1.068*exp((algebraicVariables[8]+38.3)/30.0)+1.068*exp(-(algebraicVariables[8]+38.3)/30.0)); + algebraicVariables[80] = 1.0/(1.0+exp((algebraicVariables[8]+58.7)/3.8)); + algebraicVariables[81] = 1.0/(16.67*exp(-(algebraicVariables[8]+75.0)/83.3)+16.67*exp((algebraicVariables[8]+75.0)/15.38))+constants[85]; + algebraicVariables[82] = 1.0/(1.0+exp((algebraicVariables[8]+49.0)/13.0)); + algebraicVariables[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraicVariables[8]+44.0))+0.065*exp(0.1*(algebraicVariables[8]+45.93)))+10.1); + algebraicVariables[84] = 1.0/(1.0+exp(-(algebraicVariables[8]-19.3)/15.0)); + algebraicVariables[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraicVariables[8]+30.61))+0.369*exp(-0.12*(algebraicVariables[8]+23.84)))+2.98); + algebraicVariables[86] = 1.0/(1.0+exp(-(algebraicVariables[8]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraicVariables[8]/11.9)+0.96*exp(-algebraicVariables[8]/18.5))); + algebraicVariables[87] = 4.0*((37.2*exp(algebraicVariables[8]/15.9)+0.96*exp(-algebraicVariables[8]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraicVariables[8]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraicVariables[8]/15.9)+0.96*exp(-algebraicVariables[8]/22.5)))); + algebraicVariables[88] = 1.0/(1.0+exp(-(algebraicVariables[8]+10.0144)/7.6607)); + algebraicVariables[89] = 0.84655354/(4.2*exp(algebraicVariables[8]/17.0)+0.15*exp(-algebraicVariables[8]/21.6)); + algebraicVariables[90] = 1.0/(30.0*exp(algebraicVariables[8]/10.0)+exp(-algebraicVariables[8]/12.0)); + algebraicVariables[91] = 1.0/(100.0*exp(-algebraicVariables[8]/54.645)+656.0*exp(algebraicVariables[8]/106.157)); + algebraicVariables[92] = 1.0/(1.0+exp((algebraicVariables[8]+28.6)/17.1)); + algebraicVariables[94] = sqrt(1.0/(1.0+exp(-(algebraicVariables[8]+0.6383-computedConstants[23])/10.7071))); + algebraicVariables[95] = 1.0*exp(-(algebraicVariables[8]-computedConstants[23]-5.0)/25.0); + algebraicVariables[96] = 28.0/(1.0+exp(-(algebraicVariables[8]-40.0-computedConstants[23])/3.0)); + algebraicVariables[97] = 1.0/(algebraicVariables[96]+algebraicVariables[95]); + algebraicVariables[98] = 10.0*exp(0.0133*(algebraicVariables[8]+40.0)); + algebraicVariables[99] = computedConstants[24]/(computedConstants[24]+algebraicVariables[98]); + algebraicVariables[100] = 1.0/(computedConstants[24]+algebraicVariables[98]); } diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 674a0b69d..0c9ef320b 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[15]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index fd0ce8784..9bcd8da76 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 33 CONSTANT_COUNT = 91 COMPUTED_CONSTANT_COUNT = 25 -ALGEBRAIC_COUNT = 101 +ALGEBRAIC_VARIABLE_COUNT = 101 VOI_INFO = {"name": "time", "units": "second", "component": "environment"} @@ -309,11 +309,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 6.226104e-5 states[1] = 5.0 states[2] = 0.409551 @@ -468,236 +468,236 @@ def compute_computed_constants(constants, computed_constants): computed_constants[24] = (3.5988-0.025641)/(1.0+0.0000012155/pow(1.0*constants[0], 1.6951))+0.025641 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = states[1] - algebraic[47] = constants[64] if and_func(gt_func(voi, constants[66]), lt_func(voi, constants[66]+constants[65])) else constants[67] - algebraic[8] = algebraic[47] if geq_func(constants[63], 1.0) else states[15] - algebraic[5] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(algebraic[0]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic[1] = computed_constants[0]*log(constants[2]/algebraic[0]) - algebraic[6] = states[16]*computed_constants[14]*(algebraic[8]-algebraic[1])*(1.0-constants[71]) - algebraic[51] = computed_constants[0]*log((constants[2]+0.12*constants[4])/(algebraic[0]+0.12*constants[3])) - algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]) - algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]) - algebraic[7] = algebraic[52]+algebraic[53] - algebraic[4] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[0], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[1]+110.0)/20.0), -1.0) - algebraic[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic[8]/computed_constants[0])+algebraic[0]/constants[19])+algebraic[0]/constants[18]*(1.0+algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])) - algebraic[13] = states[0]/constants[15]*exp(-constants[14]*algebraic[8]/computed_constants[0])/algebraic[20] - algebraic[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraic[8]/computed_constants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])) - algebraic[14] = constants[5]/constants[22]*exp(constants[21]*algebraic[8]/computed_constants[0])/algebraic[21] - algebraic[17] = exp(constants[16]*algebraic[8]/(2.0*computed_constants[0])) - algebraic[19] = algebraic[0]/constants[18]*algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])*exp(constants[16]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[20] - algebraic[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[21] - algebraic[9] = algebraic[18]*computed_constants[5]*(algebraic[19]+algebraic[13])+algebraic[19]*algebraic[14]*(computed_constants[5]+algebraic[17]) - algebraic[16] = algebraic[0]/(constants[13]+algebraic[0]) - algebraic[15] = exp(-constants[16]*algebraic[8]/(2.0*computed_constants[0])) - algebraic[10] = algebraic[19]*algebraic[16]*(algebraic[18]+algebraic[14])+algebraic[13]*algebraic[18]*(algebraic[16]+algebraic[15]) - algebraic[11] = algebraic[17]*algebraic[16]*(algebraic[19]+algebraic[13])+algebraic[15]*algebraic[13]*(computed_constants[5]+algebraic[17]) - algebraic[12] = algebraic[15]*computed_constants[5]*(algebraic[18]+algebraic[14])+algebraic[14]*algebraic[17]*(algebraic[16]+algebraic[15]) - algebraic[3] = (1.0-constants[12])*constants[11]*(algebraic[11]*algebraic[14]-algebraic[12]*algebraic[13])/(algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]) - rates[1] = (1.0-constants[7])*-1.0*(algebraic[7]+algebraic[6]+algebraic[5]+3.0*algebraic[4]+3.0*algebraic[3])/(1.0*(computed_constants[3]+computed_constants[2])*constants[6]) - algebraic[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])) - algebraic[25] = constants[30]/algebraic[24] - algebraic[26] = constants[31]*algebraic[24] - rates[4] = constants[33]*states[5]-algebraic[26]*states[0]*states[4]-(algebraic[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]) - rates[3] = algebraic[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]-(algebraic[26]*states[0]*states[3]-constants[33]*states[6]) - rates[6] = algebraic[26]*states[0]*states[3]-constants[33]*states[6]-(constants[32]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]) - rates[5] = constants[32]*states[6]-algebraic[25]*pow(states[0], 2.0)*states[5]-(constants[33]*states[5]-algebraic[26]*states[0]*states[4]) - algebraic[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9] - rates[9] = algebraic[31] - algebraic[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10] - rates[10] = algebraic[32] - algebraic[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11] - rates[11] = algebraic[33] - algebraic[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12] - rates[12] = algebraic[34] - algebraic[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13] - rates[13] = algebraic[35] - algebraic[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14] - rates[14] = algebraic[36] - algebraic[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])) - algebraic[28] = (states[0]-states[7])/constants[35] - rates[7] = 1.0*(algebraic[28]*computed_constants[2]-algebraic[29]*computed_constants[8])/computed_constants[3]-(constants[52]*algebraic[34]+constants[50]*algebraic[31]+constants[51]*algebraic[32]) - algebraic[22] = constants[25]*states[3]*(states[2]-states[0]) - algebraic[37] = 2.0*constants[84]*algebraic[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computed_constants[0]))*states[25]*states[24] - algebraic[38] = 2.0*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - rates[0] = algebraic[22]*computed_constants[9]/computed_constants[2]-((algebraic[38]+algebraic[37]-2.0*algebraic[3])/(2.0*constants[6]*computed_constants[2])+algebraic[28]+constants[52]*algebraic[35]) - algebraic[30] = (states[8]-states[2])/constants[38] - rates[8] = algebraic[29]-algebraic[30]*computed_constants[9]/computed_constants[8] - rates[2] = algebraic[30]-(algebraic[22]+constants[53]*algebraic[36]) - algebraic[39] = constants[76]*states[20]*states[19]*(algebraic[8]-computed_constants[1]) - algebraic[40] = constants[90]*constants[89]*(algebraic[8]-computed_constants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 - algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic[41] = (algebraic[38]+algebraic[67]+algebraic[5])*(1.0-computed_constants[19])*1.0*computed_constants[18] - algebraic[42] = constants[86]*(algebraic[8]-computed_constants[1])*states[27]*states[26] - algebraic[93] = computed_constants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraic[0])) - algebraic[43] = computed_constants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0) - algebraic[44] = constants[87]*(algebraic[8]-computed_constants[1])*(0.9*states[30]+0.1*states[29])*states[28] - algebraic[48] = states[16]*computed_constants[15]*(algebraic[8]-computed_constants[1])*(1.0-constants[71]) - algebraic[45] = algebraic[6]+algebraic[48] - algebraic[46] = algebraic[45]+algebraic[44]+algebraic[43]+algebraic[42]+algebraic[4]+algebraic[3]+algebraic[7]+algebraic[41]+algebraic[37]+algebraic[40]+algebraic[39] - rates[15] = -algebraic[46]/constants[60] - algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17])/(exp(0.066*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17]))-1.0)+0.1*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17]))))-0.054 - algebraic[50] = 0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraic[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) - rates[16] = (algebraic[50]-states[16])/algebraic[49] - algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)) - algebraic[55] = algebraic[8]+41.0 - algebraic[56] = 2000.0 if lt_func(fabs(algebraic[55]), constants[75]) else 200.0*algebraic[55]/(1.0-exp(-0.1*algebraic[55])) - algebraic[58] = 1.0/(algebraic[56]+algebraic[57]) - algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)) - rates[18] = (algebraic[54]-states[18])/algebraic[58] - algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0) - algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)) - algebraic[62] = 1.0/(algebraic[60]+algebraic[61]) - algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)) - rates[17] = (algebraic[59]-states[17])/algebraic[62] - algebraic[63] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005 - algebraic[64] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)) - rates[20] = (algebraic[64]-states[20])/algebraic[63] - algebraic[65] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05 - algebraic[66] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)) - rates[19] = (algebraic[66]-states[19])/algebraic[65] - algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[79]-computed_constants[20])/(constants[78]*(1.0+computed_constants[21]/100.0)))) - algebraic[73] = -1.80001 if eq_func(algebraic[8], -1.8) else algebraic[8] - algebraic[69] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0) - algebraic[72] = -41.80001 if eq_func(algebraic[8], -41.8) else 0.0 if eq_func(algebraic[8], 0.0) else -6.80001 if eq_func(algebraic[8], -6.8) else algebraic[8] - algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0) - algebraic[71] = 0.001/(algebraic[70]+algebraic[69]) - rates[23] = (algebraic[68]-states[23])/algebraic[71] - algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))) - algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[81])/(5.3+constants[80]))) - rates[22] = (algebraic[74]-states[22])/algebraic[75] - algebraic[76] = constants[82]/(constants[82]+states[0]) - algebraic[77] = 0.001*algebraic[76]/constants[83] - rates[21] = (algebraic[76]-states[21])/algebraic[77] - algebraic[79] = 0.001/(1.068*exp((algebraic[8]+38.3)/30.0)+1.068*exp(-(algebraic[8]+38.3)/30.0)) - algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)) - rates[25] = (algebraic[78]-states[25])/algebraic[79] - algebraic[81] = 1.0/(16.67*exp(-(algebraic[8]+75.0)/83.3)+16.67*exp((algebraic[8]+75.0)/15.38))+constants[85] - algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)) - rates[24] = (algebraic[80]-states[24])/algebraic[81] - algebraic[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[8]+44.0))+0.065*exp(0.1*(algebraic[8]+45.93)))+10.1) - algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)) - rates[27] = (algebraic[82]-states[27])/algebraic[83] - algebraic[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[8]+30.61))+0.369*exp(-0.12*(algebraic[8]+23.84)))+2.98) - algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)) - rates[26] = (algebraic[84]-states[26])/algebraic[85] - algebraic[89] = 0.84655354/(4.2*exp(algebraic[8]/17.0)+0.15*exp(-algebraic[8]/21.6)) - algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)) - rates[29] = (algebraic[88]-states[29])/algebraic[89] - algebraic[90] = 1.0/(30.0*exp(algebraic[8]/10.0)+exp(-algebraic[8]/12.0)) - rates[30] = (algebraic[88]-states[30])/algebraic[90] - algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)) - algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)) - rates[28] = (algebraic[92]-states[28])/algebraic[91] - algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computed_constants[23])/10.7071))) - algebraic[95] = 1.0*exp(-(algebraic[8]-computed_constants[23]-5.0)/25.0) - algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computed_constants[23])/3.0)) - algebraic[97] = 1.0/(algebraic[96]+algebraic[95]) - rates[31] = (algebraic[94]-states[31])/algebraic[97] - algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)) - algebraic[100] = 1.0/(computed_constants[24]+algebraic[98]) - algebraic[99] = computed_constants[24]/(computed_constants[24]+algebraic[98]) - rates[32] = (algebraic[99]-states[32])/algebraic[100] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = states[1] - algebraic[1] = computed_constants[0]*log(constants[2]/algebraic[0]) - algebraic[2] = 0.5*computed_constants[0]*log(constants[5]/states[0]) - algebraic[8] = algebraic[47] if geq_func(constants[63], 1.0) else states[15] - algebraic[4] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic[0], 1.3), -1.0)*pow(1.0+exp(-(algebraic[8]-algebraic[1]+110.0)/20.0), -1.0) - algebraic[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic[8]/computed_constants[0])+algebraic[0]/constants[19])+algebraic[0]/constants[18]*(1.0+algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])) - algebraic[13] = states[0]/constants[15]*exp(-constants[14]*algebraic[8]/computed_constants[0])/algebraic[20] - algebraic[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraic[8]/computed_constants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])) - algebraic[14] = constants[5]/constants[22]*exp(constants[21]*algebraic[8]/computed_constants[0])/algebraic[21] - algebraic[17] = exp(constants[16]*algebraic[8]/(2.0*computed_constants[0])) - algebraic[19] = algebraic[0]/constants[18]*algebraic[0]/constants[17]*(1.0+algebraic[0]/constants[13])*exp(constants[16]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[20] - algebraic[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraic[8]/(2.0*computed_constants[0]))/algebraic[21] - algebraic[9] = algebraic[18]*computed_constants[5]*(algebraic[19]+algebraic[13])+algebraic[19]*algebraic[14]*(computed_constants[5]+algebraic[17]) - algebraic[16] = algebraic[0]/(constants[13]+algebraic[0]) - algebraic[15] = exp(-constants[16]*algebraic[8]/(2.0*computed_constants[0])) - algebraic[10] = algebraic[19]*algebraic[16]*(algebraic[18]+algebraic[14])+algebraic[13]*algebraic[18]*(algebraic[16]+algebraic[15]) - algebraic[11] = algebraic[17]*algebraic[16]*(algebraic[19]+algebraic[13])+algebraic[15]*algebraic[13]*(computed_constants[5]+algebraic[17]) - algebraic[12] = algebraic[15]*computed_constants[5]*(algebraic[18]+algebraic[14])+algebraic[14]*algebraic[17]*(algebraic[16]+algebraic[15]) - algebraic[3] = (1.0-constants[12])*constants[11]*(algebraic[11]*algebraic[14]-algebraic[12]*algebraic[13])/(algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]) - algebraic[22] = constants[25]*states[3]*(states[2]-states[0]) - algebraic[23] = states[2]-states[0] - algebraic[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])) - algebraic[25] = constants[30]/algebraic[24] - algebraic[26] = constants[31]*algebraic[24] - algebraic[27] = states[4]+states[3]+states[6]+states[5] - algebraic[28] = (states[0]-states[7])/constants[35] - algebraic[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])) - algebraic[30] = (states[8]-states[2])/constants[38] - algebraic[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9] - algebraic[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10] - algebraic[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11] - algebraic[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12] - algebraic[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13] - algebraic[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14] - algebraic[39] = constants[76]*states[20]*states[19]*(algebraic[8]-computed_constants[1]) - algebraic[40] = constants[90]*constants[89]*(algebraic[8]-computed_constants[1])*(1.0+exp((algebraic[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 - algebraic[37] = 2.0*constants[84]*algebraic[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraic[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic[8]/computed_constants[0]))*states[25]*states[24] - algebraic[5] = 0.0000185*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(algebraic[0]-constants[2]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic[67] = 0.000365*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)/computed_constants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic[38] = 2.0*constants[77]*(algebraic[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic[41] = (algebraic[38]+algebraic[67]+algebraic[5])*(1.0-computed_constants[19])*1.0*computed_constants[18] - algebraic[51] = computed_constants[0]*log((constants[2]+0.12*constants[4])/(algebraic[0]+0.12*constants[3])) - algebraic[53] = constants[74]*pow(states[18], 3.0)*(algebraic[8]-algebraic[51]) - algebraic[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic[8]-algebraic[51]) - algebraic[7] = algebraic[52]+algebraic[53] - algebraic[42] = constants[86]*(algebraic[8]-computed_constants[1])*states[27]*states[26] - algebraic[93] = computed_constants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraic[0])) - algebraic[43] = computed_constants[22]*(algebraic[8]-algebraic[93])*pow(states[31], 2.0) - algebraic[44] = constants[87]*(algebraic[8]-computed_constants[1])*(0.9*states[30]+0.1*states[29])*states[28] - algebraic[48] = states[16]*computed_constants[15]*(algebraic[8]-computed_constants[1])*(1.0-constants[71]) - algebraic[6] = states[16]*computed_constants[14]*(algebraic[8]-algebraic[1])*(1.0-constants[71]) - algebraic[45] = algebraic[6]+algebraic[48] - algebraic[46] = algebraic[45]+algebraic[44]+algebraic[43]+algebraic[42]+algebraic[4]+algebraic[3]+algebraic[7]+algebraic[41]+algebraic[37]+algebraic[40]+algebraic[39] - algebraic[49] = 1.0/(0.36*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17])/(exp(0.066*(algebraic[8]+148.8-computed_constants[16]-computed_constants[17]))-1.0)+0.1*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17])/(1.0-exp(-0.2*(algebraic[8]+87.3-computed_constants[16]-computed_constants[17]))))-0.054 - algebraic[50] = 0.01329+0.99921/(1.0+exp((algebraic[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraic[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) - algebraic[54] = 1.0/(1.0+exp(-(algebraic[8]+42.0504)/8.3106)) - algebraic[55] = algebraic[8]+41.0 - algebraic[56] = 2000.0 if lt_func(fabs(algebraic[55]), constants[75]) else 200.0*algebraic[55]/(1.0-exp(-0.1*algebraic[55])) - algebraic[57] = 8000.0*exp(-0.056*(algebraic[8]+66.0)) - algebraic[58] = 1.0/(algebraic[56]+algebraic[57]) - algebraic[59] = 1.0/(1.0+exp((algebraic[8]+69.804)/4.4565)) - algebraic[60] = 20.0*exp(-0.125*(algebraic[8]+75.0)) - algebraic[61] = 2000.0/(320.0*exp(-0.1*(algebraic[8]+75.0))+1.0) - algebraic[62] = 1.0/(algebraic[60]+algebraic[61]) - algebraic[64] = 1.0/(1.0+exp((algebraic[8]+6.0)/-8.6)) - algebraic[63] = 0.009/(1.0+exp((algebraic[8]+5.0)/12.0))+0.0005 - algebraic[66] = 1.0/(1.0+exp((algebraic[8]+7.5)/10.0)) - algebraic[65] = 0.59/(1.0+exp((algebraic[8]+60.0)/10.0))+3.05 - algebraic[68] = 1.0/(1.0+exp(-(algebraic[8]-constants[79]-computed_constants[20])/(constants[78]*(1.0+computed_constants[21]/100.0)))) - algebraic[73] = -1.80001 if eq_func(algebraic[8], -1.8) else algebraic[8] - algebraic[69] = 0.01143*(algebraic[73]+1.8)/(exp((algebraic[73]+1.8)/2.5)-1.0) - algebraic[72] = -41.80001 if eq_func(algebraic[8], -41.8) else 0.0 if eq_func(algebraic[8], 0.0) else -6.80001 if eq_func(algebraic[8], -6.8) else algebraic[8] - algebraic[70] = -0.02839*(algebraic[72]+41.8)/(exp(-(algebraic[72]+41.8)/2.5)-1.0)-0.0849*(algebraic[72]+6.8)/(exp(-(algebraic[72]+6.8)/4.8)-1.0) - algebraic[71] = 0.001/(algebraic[70]+algebraic[69]) - algebraic[74] = 1.0/(1.0+exp((algebraic[8]+37.4+constants[81])/(5.3+constants[80]))) - algebraic[75] = 0.001*(44.3+230.0*exp(-pow((algebraic[8]+36.0)/10.0, 2.0))) - algebraic[76] = constants[82]/(constants[82]+states[0]) - algebraic[77] = 0.001*algebraic[76]/constants[83] - algebraic[78] = 1.0/(1.0+exp(-(algebraic[8]+38.3)/5.5)) - algebraic[79] = 0.001/(1.068*exp((algebraic[8]+38.3)/30.0)+1.068*exp(-(algebraic[8]+38.3)/30.0)) - algebraic[80] = 1.0/(1.0+exp((algebraic[8]+58.7)/3.8)) - algebraic[81] = 1.0/(16.67*exp(-(algebraic[8]+75.0)/83.3)+16.67*exp((algebraic[8]+75.0)/15.38))+constants[85] - algebraic[82] = 1.0/(1.0+exp((algebraic[8]+49.0)/13.0)) - algebraic[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic[8]+44.0))+0.065*exp(0.1*(algebraic[8]+45.93)))+10.1) - algebraic[84] = 1.0/(1.0+exp(-(algebraic[8]-19.3)/15.0)) - algebraic[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic[8]+30.61))+0.369*exp(-0.12*(algebraic[8]+23.84)))+2.98) - algebraic[86] = 1.0/(1.0+exp(-(algebraic[8]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraic[8]/11.9)+0.96*exp(-algebraic[8]/18.5))) - algebraic[87] = 4.0*((37.2*exp(algebraic[8]/15.9)+0.96*exp(-algebraic[8]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraic[8]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraic[8]/15.9)+0.96*exp(-algebraic[8]/22.5)))) - algebraic[88] = 1.0/(1.0+exp(-(algebraic[8]+10.0144)/7.6607)) - algebraic[89] = 0.84655354/(4.2*exp(algebraic[8]/17.0)+0.15*exp(-algebraic[8]/21.6)) - algebraic[90] = 1.0/(30.0*exp(algebraic[8]/10.0)+exp(-algebraic[8]/12.0)) - algebraic[91] = 1.0/(100.0*exp(-algebraic[8]/54.645)+656.0*exp(algebraic[8]/106.157)) - algebraic[92] = 1.0/(1.0+exp((algebraic[8]+28.6)/17.1)) - algebraic[94] = sqrt(1.0/(1.0+exp(-(algebraic[8]+0.6383-computed_constants[23])/10.7071))) - algebraic[95] = 1.0*exp(-(algebraic[8]-computed_constants[23]-5.0)/25.0) - algebraic[96] = 28.0/(1.0+exp(-(algebraic[8]-40.0-computed_constants[23])/3.0)) - algebraic[97] = 1.0/(algebraic[96]+algebraic[95]) - algebraic[98] = 10.0*exp(0.0133*(algebraic[8]+40.0)) - algebraic[99] = computed_constants[24]/(computed_constants[24]+algebraic[98]) - algebraic[100] = 1.0/(computed_constants[24]+algebraic[98]) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = states[1] + algebraicVariables[47] = constants[64] if and_func(gt_func(voi, constants[66]), lt_func(voi, constants[66]+constants[65])) else constants[67] + algebraicVariables[8] = algebraicVariables[47] if geq_func(constants[63], 1.0) else states[15] + algebraicVariables[5] = 0.0000185*constants[77]*(algebraicVariables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computed_constants[0])))*(algebraicVariables[0]-constants[2]*exp(-1.0*(algebraicVariables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraicVariables[1] = computed_constants[0]*log(constants[2]/algebraicVariables[0]) + algebraicVariables[6] = states[16]*computed_constants[14]*(algebraicVariables[8]-algebraicVariables[1])*(1.0-constants[71]) + algebraicVariables[51] = computed_constants[0]*log((constants[2]+0.12*constants[4])/(algebraicVariables[0]+0.12*constants[3])) + algebraicVariables[53] = constants[74]*pow(states[18], 3.0)*(algebraicVariables[8]-algebraicVariables[51]) + algebraicVariables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraicVariables[8]-algebraicVariables[51]) + algebraicVariables[7] = algebraicVariables[52]+algebraicVariables[53] + algebraicVariables[4] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraicVariables[0], 1.3), -1.0)*pow(1.0+exp(-(algebraicVariables[8]-algebraicVariables[1]+110.0)/20.0), -1.0) + algebraicVariables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraicVariables[8]/computed_constants[0])+algebraicVariables[0]/constants[19])+algebraicVariables[0]/constants[18]*(1.0+algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])) + algebraicVariables[13] = states[0]/constants[15]*exp(-constants[14]*algebraicVariables[8]/computed_constants[0])/algebraicVariables[20] + algebraicVariables[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraicVariables[8]/computed_constants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])) + algebraicVariables[14] = constants[5]/constants[22]*exp(constants[21]*algebraicVariables[8]/computed_constants[0])/algebraicVariables[21] + algebraicVariables[17] = exp(constants[16]*algebraicVariables[8]/(2.0*computed_constants[0])) + algebraicVariables[19] = algebraicVariables[0]/constants[18]*algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])*exp(constants[16]*algebraicVariables[8]/(2.0*computed_constants[0]))/algebraicVariables[20] + algebraicVariables[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraicVariables[8]/(2.0*computed_constants[0]))/algebraicVariables[21] + algebraicVariables[9] = algebraicVariables[18]*computed_constants[5]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[19]*algebraicVariables[14]*(computed_constants[5]+algebraicVariables[17]) + algebraicVariables[16] = algebraicVariables[0]/(constants[13]+algebraicVariables[0]) + algebraicVariables[15] = exp(-constants[16]*algebraicVariables[8]/(2.0*computed_constants[0])) + algebraicVariables[10] = algebraicVariables[19]*algebraicVariables[16]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[13]*algebraicVariables[18]*(algebraicVariables[16]+algebraicVariables[15]) + algebraicVariables[11] = algebraicVariables[17]*algebraicVariables[16]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[15]*algebraicVariables[13]*(computed_constants[5]+algebraicVariables[17]) + algebraicVariables[12] = algebraicVariables[15]*computed_constants[5]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[14]*algebraicVariables[17]*(algebraicVariables[16]+algebraicVariables[15]) + algebraicVariables[3] = (1.0-constants[12])*constants[11]*(algebraicVariables[11]*algebraicVariables[14]-algebraicVariables[12]*algebraicVariables[13])/(algebraicVariables[12]+algebraicVariables[11]+algebraicVariables[10]+algebraicVariables[9]) + rates[1] = (1.0-constants[7])*-1.0*(algebraicVariables[7]+algebraicVariables[6]+algebraicVariables[5]+3.0*algebraicVariables[4]+3.0*algebraicVariables[3])/(1.0*(computed_constants[3]+computed_constants[2])*constants[6]) + algebraicVariables[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])) + algebraicVariables[25] = constants[30]/algebraicVariables[24] + algebraicVariables[26] = constants[31]*algebraicVariables[24] + rates[4] = constants[33]*states[5]-algebraicVariables[26]*states[0]*states[4]-(algebraicVariables[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]) + rates[3] = algebraicVariables[25]*pow(states[0], 2.0)*states[4]-constants[32]*states[3]-(algebraicVariables[26]*states[0]*states[3]-constants[33]*states[6]) + rates[6] = algebraicVariables[26]*states[0]*states[3]-constants[33]*states[6]-(constants[32]*states[6]-algebraicVariables[25]*pow(states[0], 2.0)*states[5]) + rates[5] = constants[32]*states[6]-algebraicVariables[25]*pow(states[0], 2.0)*states[5]-(constants[33]*states[5]-algebraicVariables[26]*states[0]*states[4]) + algebraicVariables[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9] + rates[9] = algebraicVariables[31] + algebraicVariables[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10] + rates[10] = algebraicVariables[32] + algebraicVariables[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11] + rates[11] = algebraicVariables[33] + algebraicVariables[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12] + rates[12] = algebraicVariables[34] + algebraicVariables[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13] + rates[13] = algebraicVariables[35] + algebraicVariables[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14] + rates[14] = algebraicVariables[36] + algebraicVariables[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])) + algebraicVariables[28] = (states[0]-states[7])/constants[35] + rates[7] = 1.0*(algebraicVariables[28]*computed_constants[2]-algebraicVariables[29]*computed_constants[8])/computed_constants[3]-(constants[52]*algebraicVariables[34]+constants[50]*algebraicVariables[31]+constants[51]*algebraicVariables[32]) + algebraicVariables[22] = constants[25]*states[3]*(states[2]-states[0]) + algebraicVariables[37] = 2.0*constants[84]*algebraicVariables[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraicVariables[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraicVariables[8]/computed_constants[0]))*states[25]*states[24] + algebraicVariables[38] = 2.0*constants[77]*(algebraicVariables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraicVariables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + rates[0] = algebraicVariables[22]*computed_constants[9]/computed_constants[2]-((algebraicVariables[38]+algebraicVariables[37]-2.0*algebraicVariables[3])/(2.0*constants[6]*computed_constants[2])+algebraicVariables[28]+constants[52]*algebraicVariables[35]) + algebraicVariables[30] = (states[8]-states[2])/constants[38] + rates[8] = algebraicVariables[29]-algebraicVariables[30]*computed_constants[9]/computed_constants[8] + rates[2] = algebraicVariables[30]-(algebraicVariables[22]+constants[53]*algebraicVariables[36]) + algebraicVariables[39] = constants[76]*states[20]*states[19]*(algebraicVariables[8]-computed_constants[1]) + algebraicVariables[40] = constants[90]*constants[89]*(algebraicVariables[8]-computed_constants[1])*(1.0+exp((algebraicVariables[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 + algebraicVariables[67] = 0.000365*constants[77]*(algebraicVariables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computed_constants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraicVariables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraicVariables[41] = (algebraicVariables[38]+algebraicVariables[67]+algebraicVariables[5])*(1.0-computed_constants[19])*1.0*computed_constants[18] + algebraicVariables[42] = constants[86]*(algebraicVariables[8]-computed_constants[1])*states[27]*states[26] + algebraicVariables[93] = computed_constants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraicVariables[0])) + algebraicVariables[43] = computed_constants[22]*(algebraicVariables[8]-algebraicVariables[93])*pow(states[31], 2.0) + algebraicVariables[44] = constants[87]*(algebraicVariables[8]-computed_constants[1])*(0.9*states[30]+0.1*states[29])*states[28] + algebraicVariables[48] = states[16]*computed_constants[15]*(algebraicVariables[8]-computed_constants[1])*(1.0-constants[71]) + algebraicVariables[45] = algebraicVariables[6]+algebraicVariables[48] + algebraicVariables[46] = algebraicVariables[45]+algebraicVariables[44]+algebraicVariables[43]+algebraicVariables[42]+algebraicVariables[4]+algebraicVariables[3]+algebraicVariables[7]+algebraicVariables[41]+algebraicVariables[37]+algebraicVariables[40]+algebraicVariables[39] + rates[15] = -algebraicVariables[46]/constants[60] + algebraicVariables[49] = 1.0/(0.36*(algebraicVariables[8]+148.8-computed_constants[16]-computed_constants[17])/(exp(0.066*(algebraicVariables[8]+148.8-computed_constants[16]-computed_constants[17]))-1.0)+0.1*(algebraicVariables[8]+87.3-computed_constants[16]-computed_constants[17])/(1.0-exp(-0.2*(algebraicVariables[8]+87.3-computed_constants[16]-computed_constants[17]))))-0.054 + algebraicVariables[50] = 0.01329+0.99921/(1.0+exp((algebraicVariables[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraicVariables[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraicVariables[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) + rates[16] = (algebraicVariables[50]-states[16])/algebraicVariables[49] + algebraicVariables[57] = 8000.0*exp(-0.056*(algebraicVariables[8]+66.0)) + algebraicVariables[55] = algebraicVariables[8]+41.0 + algebraicVariables[56] = 2000.0 if lt_func(fabs(algebraicVariables[55]), constants[75]) else 200.0*algebraicVariables[55]/(1.0-exp(-0.1*algebraicVariables[55])) + algebraicVariables[58] = 1.0/(algebraicVariables[56]+algebraicVariables[57]) + algebraicVariables[54] = 1.0/(1.0+exp(-(algebraicVariables[8]+42.0504)/8.3106)) + rates[18] = (algebraicVariables[54]-states[18])/algebraicVariables[58] + algebraicVariables[61] = 2000.0/(320.0*exp(-0.1*(algebraicVariables[8]+75.0))+1.0) + algebraicVariables[60] = 20.0*exp(-0.125*(algebraicVariables[8]+75.0)) + algebraicVariables[62] = 1.0/(algebraicVariables[60]+algebraicVariables[61]) + algebraicVariables[59] = 1.0/(1.0+exp((algebraicVariables[8]+69.804)/4.4565)) + rates[17] = (algebraicVariables[59]-states[17])/algebraicVariables[62] + algebraicVariables[63] = 0.009/(1.0+exp((algebraicVariables[8]+5.0)/12.0))+0.0005 + algebraicVariables[64] = 1.0/(1.0+exp((algebraicVariables[8]+6.0)/-8.6)) + rates[20] = (algebraicVariables[64]-states[20])/algebraicVariables[63] + algebraicVariables[65] = 0.59/(1.0+exp((algebraicVariables[8]+60.0)/10.0))+3.05 + algebraicVariables[66] = 1.0/(1.0+exp((algebraicVariables[8]+7.5)/10.0)) + rates[19] = (algebraicVariables[66]-states[19])/algebraicVariables[65] + algebraicVariables[68] = 1.0/(1.0+exp(-(algebraicVariables[8]-constants[79]-computed_constants[20])/(constants[78]*(1.0+computed_constants[21]/100.0)))) + algebraicVariables[73] = -1.80001 if eq_func(algebraicVariables[8], -1.8) else algebraicVariables[8] + algebraicVariables[69] = 0.01143*(algebraicVariables[73]+1.8)/(exp((algebraicVariables[73]+1.8)/2.5)-1.0) + algebraicVariables[72] = -41.80001 if eq_func(algebraicVariables[8], -41.8) else 0.0 if eq_func(algebraicVariables[8], 0.0) else -6.80001 if eq_func(algebraicVariables[8], -6.8) else algebraicVariables[8] + algebraicVariables[70] = -0.02839*(algebraicVariables[72]+41.8)/(exp(-(algebraicVariables[72]+41.8)/2.5)-1.0)-0.0849*(algebraicVariables[72]+6.8)/(exp(-(algebraicVariables[72]+6.8)/4.8)-1.0) + algebraicVariables[71] = 0.001/(algebraicVariables[70]+algebraicVariables[69]) + rates[23] = (algebraicVariables[68]-states[23])/algebraicVariables[71] + algebraicVariables[75] = 0.001*(44.3+230.0*exp(-pow((algebraicVariables[8]+36.0)/10.0, 2.0))) + algebraicVariables[74] = 1.0/(1.0+exp((algebraicVariables[8]+37.4+constants[81])/(5.3+constants[80]))) + rates[22] = (algebraicVariables[74]-states[22])/algebraicVariables[75] + algebraicVariables[76] = constants[82]/(constants[82]+states[0]) + algebraicVariables[77] = 0.001*algebraicVariables[76]/constants[83] + rates[21] = (algebraicVariables[76]-states[21])/algebraicVariables[77] + algebraicVariables[79] = 0.001/(1.068*exp((algebraicVariables[8]+38.3)/30.0)+1.068*exp(-(algebraicVariables[8]+38.3)/30.0)) + algebraicVariables[78] = 1.0/(1.0+exp(-(algebraicVariables[8]+38.3)/5.5)) + rates[25] = (algebraicVariables[78]-states[25])/algebraicVariables[79] + algebraicVariables[81] = 1.0/(16.67*exp(-(algebraicVariables[8]+75.0)/83.3)+16.67*exp((algebraicVariables[8]+75.0)/15.38))+constants[85] + algebraicVariables[80] = 1.0/(1.0+exp((algebraicVariables[8]+58.7)/3.8)) + rates[24] = (algebraicVariables[80]-states[24])/algebraicVariables[81] + algebraicVariables[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraicVariables[8]+44.0))+0.065*exp(0.1*(algebraicVariables[8]+45.93)))+10.1) + algebraicVariables[82] = 1.0/(1.0+exp((algebraicVariables[8]+49.0)/13.0)) + rates[27] = (algebraicVariables[82]-states[27])/algebraicVariables[83] + algebraicVariables[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraicVariables[8]+30.61))+0.369*exp(-0.12*(algebraicVariables[8]+23.84)))+2.98) + algebraicVariables[84] = 1.0/(1.0+exp(-(algebraicVariables[8]-19.3)/15.0)) + rates[26] = (algebraicVariables[84]-states[26])/algebraicVariables[85] + algebraicVariables[89] = 0.84655354/(4.2*exp(algebraicVariables[8]/17.0)+0.15*exp(-algebraicVariables[8]/21.6)) + algebraicVariables[88] = 1.0/(1.0+exp(-(algebraicVariables[8]+10.0144)/7.6607)) + rates[29] = (algebraicVariables[88]-states[29])/algebraicVariables[89] + algebraicVariables[90] = 1.0/(30.0*exp(algebraicVariables[8]/10.0)+exp(-algebraicVariables[8]/12.0)) + rates[30] = (algebraicVariables[88]-states[30])/algebraicVariables[90] + algebraicVariables[91] = 1.0/(100.0*exp(-algebraicVariables[8]/54.645)+656.0*exp(algebraicVariables[8]/106.157)) + algebraicVariables[92] = 1.0/(1.0+exp((algebraicVariables[8]+28.6)/17.1)) + rates[28] = (algebraicVariables[92]-states[28])/algebraicVariables[91] + algebraicVariables[94] = sqrt(1.0/(1.0+exp(-(algebraicVariables[8]+0.6383-computed_constants[23])/10.7071))) + algebraicVariables[95] = 1.0*exp(-(algebraicVariables[8]-computed_constants[23]-5.0)/25.0) + algebraicVariables[96] = 28.0/(1.0+exp(-(algebraicVariables[8]-40.0-computed_constants[23])/3.0)) + algebraicVariables[97] = 1.0/(algebraicVariables[96]+algebraicVariables[95]) + rates[31] = (algebraicVariables[94]-states[31])/algebraicVariables[97] + algebraicVariables[98] = 10.0*exp(0.0133*(algebraicVariables[8]+40.0)) + algebraicVariables[100] = 1.0/(computed_constants[24]+algebraicVariables[98]) + algebraicVariables[99] = computed_constants[24]/(computed_constants[24]+algebraicVariables[98]) + rates[32] = (algebraicVariables[99]-states[32])/algebraicVariables[100] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = states[1] + algebraicVariables[1] = computed_constants[0]*log(constants[2]/algebraicVariables[0]) + algebraicVariables[2] = 0.5*computed_constants[0]*log(constants[5]/states[0]) + algebraicVariables[8] = algebraicVariables[47] if geq_func(constants[63], 1.0) else states[15] + algebraicVariables[4] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraicVariables[0], 1.3), -1.0)*pow(1.0+exp(-(algebraicVariables[8]-algebraicVariables[1]+110.0)/20.0), -1.0) + algebraicVariables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraicVariables[8]/computed_constants[0])+algebraicVariables[0]/constants[19])+algebraicVariables[0]/constants[18]*(1.0+algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])) + algebraicVariables[13] = states[0]/constants[15]*exp(-constants[14]*algebraicVariables[8]/computed_constants[0])/algebraicVariables[20] + algebraicVariables[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraicVariables[8]/computed_constants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])) + algebraicVariables[14] = constants[5]/constants[22]*exp(constants[21]*algebraicVariables[8]/computed_constants[0])/algebraicVariables[21] + algebraicVariables[17] = exp(constants[16]*algebraicVariables[8]/(2.0*computed_constants[0])) + algebraicVariables[19] = algebraicVariables[0]/constants[18]*algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])*exp(constants[16]*algebraicVariables[8]/(2.0*computed_constants[0]))/algebraicVariables[20] + algebraicVariables[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraicVariables[8]/(2.0*computed_constants[0]))/algebraicVariables[21] + algebraicVariables[9] = algebraicVariables[18]*computed_constants[5]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[19]*algebraicVariables[14]*(computed_constants[5]+algebraicVariables[17]) + algebraicVariables[16] = algebraicVariables[0]/(constants[13]+algebraicVariables[0]) + algebraicVariables[15] = exp(-constants[16]*algebraicVariables[8]/(2.0*computed_constants[0])) + algebraicVariables[10] = algebraicVariables[19]*algebraicVariables[16]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[13]*algebraicVariables[18]*(algebraicVariables[16]+algebraicVariables[15]) + algebraicVariables[11] = algebraicVariables[17]*algebraicVariables[16]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[15]*algebraicVariables[13]*(computed_constants[5]+algebraicVariables[17]) + algebraicVariables[12] = algebraicVariables[15]*computed_constants[5]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[14]*algebraicVariables[17]*(algebraicVariables[16]+algebraicVariables[15]) + algebraicVariables[3] = (1.0-constants[12])*constants[11]*(algebraicVariables[11]*algebraicVariables[14]-algebraicVariables[12]*algebraicVariables[13])/(algebraicVariables[12]+algebraicVariables[11]+algebraicVariables[10]+algebraicVariables[9]) + algebraicVariables[22] = constants[25]*states[3]*(states[2]-states[0]) + algebraicVariables[23] = states[2]-states[0] + algebraicVariables[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])) + algebraicVariables[25] = constants[30]/algebraicVariables[24] + algebraicVariables[26] = constants[31]*algebraicVariables[24] + algebraicVariables[27] = states[4]+states[3]+states[6]+states[5] + algebraicVariables[28] = (states[0]-states[7])/constants[35] + algebraicVariables[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])) + algebraicVariables[30] = (states[8]-states[2])/constants[38] + algebraicVariables[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9] + algebraicVariables[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10] + algebraicVariables[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11] + algebraicVariables[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12] + algebraicVariables[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13] + algebraicVariables[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14] + algebraicVariables[39] = constants[76]*states[20]*states[19]*(algebraicVariables[8]-computed_constants[1]) + algebraicVariables[40] = constants[90]*constants[89]*(algebraicVariables[8]-computed_constants[1])*(1.0+exp((algebraicVariables[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 + algebraicVariables[37] = 2.0*constants[84]*algebraicVariables[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraicVariables[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraicVariables[8]/computed_constants[0]))*states[25]*states[24] + algebraicVariables[5] = 0.0000185*constants[77]*(algebraicVariables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computed_constants[0])))*(algebraicVariables[0]-constants[2]*exp(-1.0*(algebraicVariables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraicVariables[67] = 0.000365*constants[77]*(algebraicVariables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computed_constants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraicVariables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraicVariables[38] = 2.0*constants[77]*(algebraicVariables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraicVariables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] + algebraicVariables[41] = (algebraicVariables[38]+algebraicVariables[67]+algebraicVariables[5])*(1.0-computed_constants[19])*1.0*computed_constants[18] + algebraicVariables[51] = computed_constants[0]*log((constants[2]+0.12*constants[4])/(algebraicVariables[0]+0.12*constants[3])) + algebraicVariables[53] = constants[74]*pow(states[18], 3.0)*(algebraicVariables[8]-algebraicVariables[51]) + algebraicVariables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraicVariables[8]-algebraicVariables[51]) + algebraicVariables[7] = algebraicVariables[52]+algebraicVariables[53] + algebraicVariables[42] = constants[86]*(algebraicVariables[8]-computed_constants[1])*states[27]*states[26] + algebraicVariables[93] = computed_constants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraicVariables[0])) + algebraicVariables[43] = computed_constants[22]*(algebraicVariables[8]-algebraicVariables[93])*pow(states[31], 2.0) + algebraicVariables[44] = constants[87]*(algebraicVariables[8]-computed_constants[1])*(0.9*states[30]+0.1*states[29])*states[28] + algebraicVariables[48] = states[16]*computed_constants[15]*(algebraicVariables[8]-computed_constants[1])*(1.0-constants[71]) + algebraicVariables[6] = states[16]*computed_constants[14]*(algebraicVariables[8]-algebraicVariables[1])*(1.0-constants[71]) + algebraicVariables[45] = algebraicVariables[6]+algebraicVariables[48] + algebraicVariables[46] = algebraicVariables[45]+algebraicVariables[44]+algebraicVariables[43]+algebraicVariables[42]+algebraicVariables[4]+algebraicVariables[3]+algebraicVariables[7]+algebraicVariables[41]+algebraicVariables[37]+algebraicVariables[40]+algebraicVariables[39] + algebraicVariables[49] = 1.0/(0.36*(algebraicVariables[8]+148.8-computed_constants[16]-computed_constants[17])/(exp(0.066*(algebraicVariables[8]+148.8-computed_constants[16]-computed_constants[17]))-1.0)+0.1*(algebraicVariables[8]+87.3-computed_constants[16]-computed_constants[17])/(1.0-exp(-0.2*(algebraicVariables[8]+87.3-computed_constants[16]-computed_constants[17]))))-0.054 + algebraicVariables[50] = 0.01329+0.99921/(1.0+exp((algebraicVariables[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraicVariables[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraicVariables[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) + algebraicVariables[54] = 1.0/(1.0+exp(-(algebraicVariables[8]+42.0504)/8.3106)) + algebraicVariables[55] = algebraicVariables[8]+41.0 + algebraicVariables[56] = 2000.0 if lt_func(fabs(algebraicVariables[55]), constants[75]) else 200.0*algebraicVariables[55]/(1.0-exp(-0.1*algebraicVariables[55])) + algebraicVariables[57] = 8000.0*exp(-0.056*(algebraicVariables[8]+66.0)) + algebraicVariables[58] = 1.0/(algebraicVariables[56]+algebraicVariables[57]) + algebraicVariables[59] = 1.0/(1.0+exp((algebraicVariables[8]+69.804)/4.4565)) + algebraicVariables[60] = 20.0*exp(-0.125*(algebraicVariables[8]+75.0)) + algebraicVariables[61] = 2000.0/(320.0*exp(-0.1*(algebraicVariables[8]+75.0))+1.0) + algebraicVariables[62] = 1.0/(algebraicVariables[60]+algebraicVariables[61]) + algebraicVariables[64] = 1.0/(1.0+exp((algebraicVariables[8]+6.0)/-8.6)) + algebraicVariables[63] = 0.009/(1.0+exp((algebraicVariables[8]+5.0)/12.0))+0.0005 + algebraicVariables[66] = 1.0/(1.0+exp((algebraicVariables[8]+7.5)/10.0)) + algebraicVariables[65] = 0.59/(1.0+exp((algebraicVariables[8]+60.0)/10.0))+3.05 + algebraicVariables[68] = 1.0/(1.0+exp(-(algebraicVariables[8]-constants[79]-computed_constants[20])/(constants[78]*(1.0+computed_constants[21]/100.0)))) + algebraicVariables[73] = -1.80001 if eq_func(algebraicVariables[8], -1.8) else algebraicVariables[8] + algebraicVariables[69] = 0.01143*(algebraicVariables[73]+1.8)/(exp((algebraicVariables[73]+1.8)/2.5)-1.0) + algebraicVariables[72] = -41.80001 if eq_func(algebraicVariables[8], -41.8) else 0.0 if eq_func(algebraicVariables[8], 0.0) else -6.80001 if eq_func(algebraicVariables[8], -6.8) else algebraicVariables[8] + algebraicVariables[70] = -0.02839*(algebraicVariables[72]+41.8)/(exp(-(algebraicVariables[72]+41.8)/2.5)-1.0)-0.0849*(algebraicVariables[72]+6.8)/(exp(-(algebraicVariables[72]+6.8)/4.8)-1.0) + algebraicVariables[71] = 0.001/(algebraicVariables[70]+algebraicVariables[69]) + algebraicVariables[74] = 1.0/(1.0+exp((algebraicVariables[8]+37.4+constants[81])/(5.3+constants[80]))) + algebraicVariables[75] = 0.001*(44.3+230.0*exp(-pow((algebraicVariables[8]+36.0)/10.0, 2.0))) + algebraicVariables[76] = constants[82]/(constants[82]+states[0]) + algebraicVariables[77] = 0.001*algebraicVariables[76]/constants[83] + algebraicVariables[78] = 1.0/(1.0+exp(-(algebraicVariables[8]+38.3)/5.5)) + algebraicVariables[79] = 0.001/(1.068*exp((algebraicVariables[8]+38.3)/30.0)+1.068*exp(-(algebraicVariables[8]+38.3)/30.0)) + algebraicVariables[80] = 1.0/(1.0+exp((algebraicVariables[8]+58.7)/3.8)) + algebraicVariables[81] = 1.0/(16.67*exp(-(algebraicVariables[8]+75.0)/83.3)+16.67*exp((algebraicVariables[8]+75.0)/15.38))+constants[85] + algebraicVariables[82] = 1.0/(1.0+exp((algebraicVariables[8]+49.0)/13.0)) + algebraicVariables[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraicVariables[8]+44.0))+0.065*exp(0.1*(algebraicVariables[8]+45.93)))+10.1) + algebraicVariables[84] = 1.0/(1.0+exp(-(algebraicVariables[8]-19.3)/15.0)) + algebraicVariables[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraicVariables[8]+30.61))+0.369*exp(-0.12*(algebraicVariables[8]+23.84)))+2.98) + algebraicVariables[86] = 1.0/(1.0+exp(-(algebraicVariables[8]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraicVariables[8]/11.9)+0.96*exp(-algebraicVariables[8]/18.5))) + algebraicVariables[87] = 4.0*((37.2*exp(algebraicVariables[8]/15.9)+0.96*exp(-algebraicVariables[8]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraicVariables[8]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraicVariables[8]/15.9)+0.96*exp(-algebraicVariables[8]/22.5)))) + algebraicVariables[88] = 1.0/(1.0+exp(-(algebraicVariables[8]+10.0144)/7.6607)) + algebraicVariables[89] = 0.84655354/(4.2*exp(algebraicVariables[8]/17.0)+0.15*exp(-algebraicVariables[8]/21.6)) + algebraicVariables[90] = 1.0/(30.0*exp(algebraicVariables[8]/10.0)+exp(-algebraicVariables[8]/12.0)) + algebraicVariables[91] = 1.0/(100.0*exp(-algebraicVariables[8]/54.645)+656.0*exp(algebraicVariables[8]/106.157)) + algebraicVariables[92] = 1.0/(1.0+exp((algebraicVariables[8]+28.6)/17.1)) + algebraicVariables[94] = sqrt(1.0/(1.0+exp(-(algebraicVariables[8]+0.6383-computed_constants[23])/10.7071))) + algebraicVariables[95] = 1.0*exp(-(algebraicVariables[8]-computed_constants[23]-5.0)/25.0) + algebraicVariables[96] = 28.0/(1.0+exp(-(algebraicVariables[8]-40.0-computed_constants[23])/3.0)) + algebraicVariables[97] = 1.0/(algebraicVariables[96]+algebraicVariables[95]) + algebraicVariables[98] = 10.0*exp(0.0133*(algebraicVariables[8]+40.0)) + algebraicVariables[99] = computed_constants[24]/(computed_constants[24]+algebraicVariables[98]) + algebraicVariables[100] = 1.0/(computed_constants[24]+algebraicVariables[98]) diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 38344edb9..6e1406536 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 15; const size_t CONSTANT_COUNT = 110; const size_t COMPUTED_CONSTANT_COUNT = 23; -const size_t ALGEBRAIC_COUNT = 52; +const size_t ALGEBRAIC_VARIABLE_COUNT = 52; const VariableInfo VOI_INFO = {"time", "second", "environment"}; @@ -260,11 +260,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -276,7 +276,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = -39.013558536; states[1] = 0.092361701692; @@ -432,129 +432,129 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[22] = (constants[1] == 0.0)?constants[104]+computedConstants[0]*(constants[105]-constants[104]):(constants[1] == 1.0)?constants[108]+computedConstants[0]*(constants[109]-constants[108]):constants[106]+computedConstants[0]*(constants[107]-constants[106]); } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); - algebraic[1] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))); - algebraic[5] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); - algebraic[6] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); - algebraic[7] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); - algebraic[9] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); - algebraic[10] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); - algebraic[11] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); - algebraic[12] = computedConstants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); - algebraic[2] = computedConstants[5]*(states[0]-computedConstants[6]); - algebraic[3] = computedConstants[7]*(states[0]-computedConstants[8]); - algebraic[4] = computedConstants[3]*(states[0]-computedConstants[4]); - algebraic[42] = 0.6*states[12]+0.4*states[11]; - algebraic[8] = computedConstants[18]*algebraic[42]*states[10]*(states[0]-computedConstants[6]); - algebraic[17] = (constants[1] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; - algebraic[14] = (1.0-algebraic[17])*states[3]+algebraic[17]*states[2]; - algebraic[13] = computedConstants[13]*pow(states[1], 3.0)*algebraic[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; - rates[0] = -1.0/computedConstants[1]*(algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+algebraic[8]+algebraic[7]+algebraic[6]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[2]+algebraic[1]+algebraic[0]+computedConstants[2]); - algebraic[15] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; - algebraic[16] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); - rates[1] = (algebraic[16]-states[1])/algebraic[15]; - algebraic[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; - algebraic[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); - rates[3] = (algebraic[19]-states[3])/algebraic[18]; - algebraic[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; - algebraic[21] = algebraic[19]; - rates[2] = (algebraic[21]-states[2])/algebraic[20]; - algebraic[25] = (constants[1] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); - algebraic[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); - algebraic[22] = 2.0/(algebraic[24]+algebraic[25]); - algebraic[23] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); - rates[4] = (algebraic[23]-states[4])/algebraic[22]; - algebraic[29] = (constants[1] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); - algebraic[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); - algebraic[26] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[28]+algebraic[29]):1.0/(algebraic[28]+algebraic[29]); - algebraic[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); - rates[5] = (algebraic[27]-states[5])/algebraic[26]; - algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0); - algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0); - algebraic[30] = 1.0/(algebraic[32]+algebraic[33]); - algebraic[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); - rates[7] = (algebraic[31]-states[7])/algebraic[30]; - algebraic[37] = (constants[1] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); - algebraic[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); - algebraic[34] = 1.0/(algebraic[36]+algebraic[37]); - algebraic[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); - rates[6] = (algebraic[35]-states[6])/algebraic[34]; - algebraic[38] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); - algebraic[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); - rates[9] = (algebraic[39]-states[9])/algebraic[38]; - algebraic[40] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); - algebraic[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); - rates[8] = (algebraic[41]-states[8])/algebraic[40]; - algebraic[43] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); - algebraic[44] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); - rates[12] = (algebraic[44]-states[12])/algebraic[43]; - algebraic[45] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); - algebraic[46] = algebraic[44]; - rates[11] = (algebraic[46]-states[11])/algebraic[45]; - algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); - rates[10] = (algebraic[47]-states[10])/computedConstants[19]; - algebraic[48] = 1.0*exp(-states[0]/45.0); - algebraic[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); - rates[13] = algebraic[49]*(1.0-states[13])-algebraic[48]*states[13]; - algebraic[50] = 1.0*exp((states[0]+75.13)/21.25); - algebraic[51] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); - rates[14] = algebraic[51]*(1.0-states[14])-algebraic[50]*states[14]; + algebraicVariables[0] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); + algebraicVariables[1] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))); + algebraicVariables[5] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); + algebraicVariables[6] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); + algebraicVariables[7] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); + algebraicVariables[9] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); + algebraicVariables[10] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); + algebraicVariables[11] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); + algebraicVariables[12] = computedConstants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); + algebraicVariables[2] = computedConstants[5]*(states[0]-computedConstants[6]); + algebraicVariables[3] = computedConstants[7]*(states[0]-computedConstants[8]); + algebraicVariables[4] = computedConstants[3]*(states[0]-computedConstants[4]); + algebraicVariables[42] = 0.6*states[12]+0.4*states[11]; + algebraicVariables[8] = computedConstants[18]*algebraicVariables[42]*states[10]*(states[0]-computedConstants[6]); + algebraicVariables[17] = (constants[1] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; + algebraicVariables[14] = (1.0-algebraicVariables[17])*states[3]+algebraicVariables[17]*states[2]; + algebraicVariables[13] = computedConstants[13]*pow(states[1], 3.0)*algebraicVariables[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; + rates[0] = -1.0/computedConstants[1]*(algebraicVariables[13]+algebraicVariables[12]+algebraicVariables[11]+algebraicVariables[10]+algebraicVariables[9]+algebraicVariables[8]+algebraicVariables[7]+algebraicVariables[6]+algebraicVariables[5]+algebraicVariables[4]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0]+computedConstants[2]); + algebraicVariables[15] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; + algebraicVariables[16] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); + rates[1] = (algebraicVariables[16]-states[1])/algebraicVariables[15]; + algebraicVariables[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; + algebraicVariables[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); + rates[3] = (algebraicVariables[19]-states[3])/algebraicVariables[18]; + algebraicVariables[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; + algebraicVariables[21] = algebraicVariables[19]; + rates[2] = (algebraicVariables[21]-states[2])/algebraicVariables[20]; + algebraicVariables[25] = (constants[1] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); + algebraicVariables[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); + algebraicVariables[22] = 2.0/(algebraicVariables[24]+algebraicVariables[25]); + algebraicVariables[23] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); + rates[4] = (algebraicVariables[23]-states[4])/algebraicVariables[22]; + algebraicVariables[29] = (constants[1] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); + algebraicVariables[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); + algebraicVariables[26] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraicVariables[28]+algebraicVariables[29]):1.0/(algebraicVariables[28]+algebraicVariables[29]); + algebraicVariables[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); + rates[5] = (algebraicVariables[27]-states[5])/algebraicVariables[26]; + algebraicVariables[33] = 1068.0*exp(-(states[0]+26.3)/30.0); + algebraicVariables[32] = 1068.0*exp((states[0]+26.3)/30.0); + algebraicVariables[30] = 1.0/(algebraicVariables[32]+algebraicVariables[33]); + algebraicVariables[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); + rates[7] = (algebraicVariables[31]-states[7])/algebraicVariables[30]; + algebraicVariables[37] = (constants[1] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); + algebraicVariables[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); + algebraicVariables[34] = 1.0/(algebraicVariables[36]+algebraicVariables[37]); + algebraicVariables[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); + rates[6] = (algebraicVariables[35]-states[6])/algebraicVariables[34]; + algebraicVariables[38] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); + algebraicVariables[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); + rates[9] = (algebraicVariables[39]-states[9])/algebraicVariables[38]; + algebraicVariables[40] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); + algebraicVariables[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); + rates[8] = (algebraicVariables[41]-states[8])/algebraicVariables[40]; + algebraicVariables[43] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); + algebraicVariables[44] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); + rates[12] = (algebraicVariables[44]-states[12])/algebraicVariables[43]; + algebraicVariables[45] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); + algebraicVariables[46] = algebraicVariables[44]; + rates[11] = (algebraicVariables[46]-states[11])/algebraicVariables[45]; + algebraicVariables[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); + rates[10] = (algebraicVariables[47]-states[10])/computedConstants[19]; + algebraicVariables[48] = 1.0*exp(-states[0]/45.0); + algebraicVariables[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); + rates[13] = algebraicVariables[49]*(1.0-states[13])-algebraicVariables[48]*states[13]; + algebraicVariables[50] = 1.0*exp((states[0]+75.13)/21.25); + algebraicVariables[51] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); + rates[14] = algebraicVariables[51]*(1.0-states[14])-algebraicVariables[50]*states[14]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[4] = computedConstants[3]*(states[0]-computedConstants[4]); - algebraic[2] = computedConstants[5]*(states[0]-computedConstants[6]); - algebraic[3] = computedConstants[7]*(states[0]-computedConstants[8]); - algebraic[1] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))); - algebraic[0] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); - algebraic[17] = (constants[1] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; - algebraic[14] = (1.0-algebraic[17])*states[3]+algebraic[17]*states[2]; - algebraic[13] = computedConstants[13]*pow(states[1], 3.0)*algebraic[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; - algebraic[16] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); - algebraic[15] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; - algebraic[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); - algebraic[21] = algebraic[19]; - algebraic[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; - algebraic[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; - algebraic[12] = computedConstants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); - algebraic[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); - algebraic[25] = (constants[1] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); - algebraic[22] = 2.0/(algebraic[24]+algebraic[25]); - algebraic[23] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); - algebraic[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); - algebraic[29] = (constants[1] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); - algebraic[26] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraic[28]+algebraic[29]):1.0/(algebraic[28]+algebraic[29]); - algebraic[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); - algebraic[11] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); - algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0); - algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0); - algebraic[30] = 1.0/(algebraic[32]+algebraic[33]); - algebraic[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); - algebraic[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); - algebraic[37] = (constants[1] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); - algebraic[34] = 1.0/(algebraic[36]+algebraic[37]); - algebraic[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); - algebraic[10] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); - algebraic[9] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); - algebraic[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); - algebraic[38] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); - algebraic[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); - algebraic[40] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); - algebraic[42] = 0.6*states[12]+0.4*states[11]; - algebraic[8] = computedConstants[18]*algebraic[42]*states[10]*(states[0]-computedConstants[6]); - algebraic[44] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); - algebraic[43] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); - algebraic[46] = algebraic[44]; - algebraic[45] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); - algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); - algebraic[7] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); - algebraic[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); - algebraic[48] = 1.0*exp(-states[0]/45.0); - algebraic[6] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); - algebraic[5] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); - algebraic[51] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); - algebraic[50] = 1.0*exp((states[0]+75.13)/21.25); + algebraicVariables[4] = computedConstants[3]*(states[0]-computedConstants[4]); + algebraicVariables[2] = computedConstants[5]*(states[0]-computedConstants[6]); + algebraicVariables[3] = computedConstants[7]*(states[0]-computedConstants[8]); + algebraicVariables[1] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))); + algebraicVariables[0] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); + algebraicVariables[17] = (constants[1] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; + algebraicVariables[14] = (1.0-algebraicVariables[17])*states[3]+algebraicVariables[17]*states[2]; + algebraicVariables[13] = computedConstants[13]*pow(states[1], 3.0)*algebraicVariables[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; + algebraicVariables[16] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); + algebraicVariables[15] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; + algebraicVariables[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); + algebraicVariables[21] = algebraicVariables[19]; + algebraicVariables[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; + algebraicVariables[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; + algebraicVariables[12] = computedConstants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); + algebraicVariables[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); + algebraicVariables[25] = (constants[1] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); + algebraicVariables[22] = 2.0/(algebraicVariables[24]+algebraicVariables[25]); + algebraicVariables[23] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); + algebraicVariables[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); + algebraicVariables[29] = (constants[1] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); + algebraicVariables[26] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraicVariables[28]+algebraicVariables[29]):1.0/(algebraicVariables[28]+algebraicVariables[29]); + algebraicVariables[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); + algebraicVariables[11] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); + algebraicVariables[32] = 1068.0*exp((states[0]+26.3)/30.0); + algebraicVariables[33] = 1068.0*exp(-(states[0]+26.3)/30.0); + algebraicVariables[30] = 1.0/(algebraicVariables[32]+algebraicVariables[33]); + algebraicVariables[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); + algebraicVariables[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); + algebraicVariables[37] = (constants[1] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); + algebraicVariables[34] = 1.0/(algebraicVariables[36]+algebraicVariables[37]); + algebraicVariables[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); + algebraicVariables[10] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); + algebraicVariables[9] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); + algebraicVariables[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); + algebraicVariables[38] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); + algebraicVariables[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); + algebraicVariables[40] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); + algebraicVariables[42] = 0.6*states[12]+0.4*states[11]; + algebraicVariables[8] = computedConstants[18]*algebraicVariables[42]*states[10]*(states[0]-computedConstants[6]); + algebraicVariables[44] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); + algebraicVariables[43] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); + algebraicVariables[46] = algebraicVariables[44]; + algebraicVariables[45] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); + algebraicVariables[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); + algebraicVariables[7] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); + algebraicVariables[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); + algebraicVariables[48] = 1.0*exp(-states[0]/45.0); + algebraicVariables[6] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); + algebraicVariables[5] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); + algebraicVariables[51] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); + algebraicVariables[50] = 1.0*exp((states[0]+75.13)/21.25); } diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index ae87fb8a1..7c2eecaec 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[31]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index 049b8e1fd..d8f15a60d 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 15 CONSTANT_COUNT = 110 COMPUTED_CONSTANT_COUNT = 23 -ALGEBRAIC_COUNT = 52 +ALGEBRAIC_VARIABLE_COUNT = 52 VOI_INFO = {"name": "time", "units": "second", "component": "environment"} @@ -247,11 +247,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = -39.013558536 states[1] = 0.092361701692 states[2] = 0.01445216109 @@ -405,126 +405,126 @@ def compute_computed_constants(constants, computed_constants): computed_constants[22] = constants[104]+computed_constants[0]*(constants[105]-constants[104]) if eq_func(constants[1], 0.0) else constants[108]+computed_constants[0]*(constants[109]-constants[108]) if eq_func(constants[1], 1.0) else constants[106]+computed_constants[0]*(constants[107]-constants[106]) -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) - algebraic[1] = computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) - algebraic[5] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) - algebraic[6] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) - algebraic[7] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) - algebraic[9] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) - algebraic[10] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) - algebraic[11] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) - algebraic[12] = computed_constants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) - algebraic[2] = computed_constants[5]*(states[0]-computed_constants[6]) - algebraic[3] = computed_constants[7]*(states[0]-computed_constants[8]) - algebraic[4] = computed_constants[3]*(states[0]-computed_constants[4]) - algebraic[42] = 0.6*states[12]+0.4*states[11] - algebraic[8] = computed_constants[18]*algebraic[42]*states[10]*(states[0]-computed_constants[6]) - algebraic[17] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[1], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 - algebraic[14] = (1.0-algebraic[17])*states[3]+algebraic[17]*states[2] - algebraic[13] = computed_constants[13]*pow(states[1], 3.0)*algebraic[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] - rates[0] = -1.0/computed_constants[1]*(algebraic[13]+algebraic[12]+algebraic[11]+algebraic[10]+algebraic[9]+algebraic[8]+algebraic[7]+algebraic[6]+algebraic[5]+algebraic[4]+algebraic[3]+algebraic[2]+algebraic[1]+algebraic[0]+computed_constants[2]) - algebraic[15] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 - algebraic[16] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) - rates[1] = (algebraic[16]-states[1])/algebraic[15] - algebraic[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 - algebraic[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) - rates[3] = (algebraic[19]-states[3])/algebraic[18] - algebraic[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 - algebraic[21] = algebraic[19] - rates[2] = (algebraic[21]-states[2])/algebraic[20] - algebraic[25] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[1], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) - algebraic[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) - algebraic[22] = 2.0/(algebraic[24]+algebraic[25]) - algebraic[23] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) - rates[4] = (algebraic[23]-states[4])/algebraic[22] - algebraic[29] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) - algebraic[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) - algebraic[26] = (1.2-0.2*computed_constants[0])/(algebraic[28]+algebraic[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraic[28]+algebraic[29]) - algebraic[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) - rates[5] = (algebraic[27]-states[5])/algebraic[26] - algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0) - algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0) - algebraic[30] = 1.0/(algebraic[32]+algebraic[33]) - algebraic[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) - rates[7] = (algebraic[31]-states[7])/algebraic[30] - algebraic[37] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[1], 1.0) else 15.0*exp((states[0]+71.7)/15.38) - algebraic[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) - algebraic[34] = 1.0/(algebraic[36]+algebraic[37]) - algebraic[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) - rates[6] = (algebraic[35]-states[6])/algebraic[34] - algebraic[38] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) - algebraic[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) - rates[9] = (algebraic[39]-states[9])/algebraic[38] - algebraic[40] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) - algebraic[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) - rates[8] = (algebraic[41]-states[8])/algebraic[40] - algebraic[43] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) - algebraic[44] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) - rates[12] = (algebraic[44]-states[12])/algebraic[43] - algebraic[45] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) - algebraic[46] = algebraic[44] - rates[11] = (algebraic[46]-states[11])/algebraic[45] - algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) - rates[10] = (algebraic[47]-states[10])/computed_constants[19] - algebraic[48] = 1.0*exp(-states[0]/45.0) - algebraic[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) - rates[13] = algebraic[49]*(1.0-states[13])-algebraic[48]*states[13] - algebraic[50] = 1.0*exp((states[0]+75.13)/21.25) - algebraic[51] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) - rates[14] = algebraic[51]*(1.0-states[14])-algebraic[50]*states[14] +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) + algebraicVariables[1] = computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) + algebraicVariables[5] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) + algebraicVariables[6] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) + algebraicVariables[7] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) + algebraicVariables[9] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) + algebraicVariables[10] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) + algebraicVariables[11] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) + algebraicVariables[12] = computed_constants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) + algebraicVariables[2] = computed_constants[5]*(states[0]-computed_constants[6]) + algebraicVariables[3] = computed_constants[7]*(states[0]-computed_constants[8]) + algebraicVariables[4] = computed_constants[3]*(states[0]-computed_constants[4]) + algebraicVariables[42] = 0.6*states[12]+0.4*states[11] + algebraicVariables[8] = computed_constants[18]*algebraicVariables[42]*states[10]*(states[0]-computed_constants[6]) + algebraicVariables[17] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[1], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 + algebraicVariables[14] = (1.0-algebraicVariables[17])*states[3]+algebraicVariables[17]*states[2] + algebraicVariables[13] = computed_constants[13]*pow(states[1], 3.0)*algebraicVariables[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] + rates[0] = -1.0/computed_constants[1]*(algebraicVariables[13]+algebraicVariables[12]+algebraicVariables[11]+algebraicVariables[10]+algebraicVariables[9]+algebraicVariables[8]+algebraicVariables[7]+algebraicVariables[6]+algebraicVariables[5]+algebraicVariables[4]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0]+computed_constants[2]) + algebraicVariables[15] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 + algebraicVariables[16] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) + rates[1] = (algebraicVariables[16]-states[1])/algebraicVariables[15] + algebraicVariables[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 + algebraicVariables[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) + rates[3] = (algebraicVariables[19]-states[3])/algebraicVariables[18] + algebraicVariables[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 + algebraicVariables[21] = algebraicVariables[19] + rates[2] = (algebraicVariables[21]-states[2])/algebraicVariables[20] + algebraicVariables[25] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[1], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) + algebraicVariables[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) + algebraicVariables[22] = 2.0/(algebraicVariables[24]+algebraicVariables[25]) + algebraicVariables[23] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) + rates[4] = (algebraicVariables[23]-states[4])/algebraicVariables[22] + algebraicVariables[29] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) + algebraicVariables[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) + algebraicVariables[26] = (1.2-0.2*computed_constants[0])/(algebraicVariables[28]+algebraicVariables[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraicVariables[28]+algebraicVariables[29]) + algebraicVariables[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) + rates[5] = (algebraicVariables[27]-states[5])/algebraicVariables[26] + algebraicVariables[33] = 1068.0*exp(-(states[0]+26.3)/30.0) + algebraicVariables[32] = 1068.0*exp((states[0]+26.3)/30.0) + algebraicVariables[30] = 1.0/(algebraicVariables[32]+algebraicVariables[33]) + algebraicVariables[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) + rates[7] = (algebraicVariables[31]-states[7])/algebraicVariables[30] + algebraicVariables[37] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[1], 1.0) else 15.0*exp((states[0]+71.7)/15.38) + algebraicVariables[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) + algebraicVariables[34] = 1.0/(algebraicVariables[36]+algebraicVariables[37]) + algebraicVariables[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) + rates[6] = (algebraicVariables[35]-states[6])/algebraicVariables[34] + algebraicVariables[38] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) + algebraicVariables[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) + rates[9] = (algebraicVariables[39]-states[9])/algebraicVariables[38] + algebraicVariables[40] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) + algebraicVariables[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) + rates[8] = (algebraicVariables[41]-states[8])/algebraicVariables[40] + algebraicVariables[43] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) + algebraicVariables[44] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) + rates[12] = (algebraicVariables[44]-states[12])/algebraicVariables[43] + algebraicVariables[45] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) + algebraicVariables[46] = algebraicVariables[44] + rates[11] = (algebraicVariables[46]-states[11])/algebraicVariables[45] + algebraicVariables[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) + rates[10] = (algebraicVariables[47]-states[10])/computed_constants[19] + algebraicVariables[48] = 1.0*exp(-states[0]/45.0) + algebraicVariables[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) + rates[13] = algebraicVariables[49]*(1.0-states[13])-algebraicVariables[48]*states[13] + algebraicVariables[50] = 1.0*exp((states[0]+75.13)/21.25) + algebraicVariables[51] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) + rates[14] = algebraicVariables[51]*(1.0-states[14])-algebraicVariables[50]*states[14] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[4] = computed_constants[3]*(states[0]-computed_constants[4]) - algebraic[2] = computed_constants[5]*(states[0]-computed_constants[6]) - algebraic[3] = computed_constants[7]*(states[0]-computed_constants[8]) - algebraic[1] = computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) - algebraic[0] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) - algebraic[17] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[1], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 - algebraic[14] = (1.0-algebraic[17])*states[3]+algebraic[17]*states[2] - algebraic[13] = computed_constants[13]*pow(states[1], 3.0)*algebraic[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] - algebraic[16] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) - algebraic[15] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 - algebraic[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) - algebraic[21] = algebraic[19] - algebraic[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 - algebraic[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 - algebraic[12] = computed_constants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) - algebraic[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) - algebraic[25] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[1], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) - algebraic[22] = 2.0/(algebraic[24]+algebraic[25]) - algebraic[23] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) - algebraic[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) - algebraic[29] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) - algebraic[26] = (1.2-0.2*computed_constants[0])/(algebraic[28]+algebraic[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraic[28]+algebraic[29]) - algebraic[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) - algebraic[11] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) - algebraic[32] = 1068.0*exp((states[0]+26.3)/30.0) - algebraic[33] = 1068.0*exp(-(states[0]+26.3)/30.0) - algebraic[30] = 1.0/(algebraic[32]+algebraic[33]) - algebraic[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) - algebraic[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) - algebraic[37] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[1], 1.0) else 15.0*exp((states[0]+71.7)/15.38) - algebraic[34] = 1.0/(algebraic[36]+algebraic[37]) - algebraic[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) - algebraic[10] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) - algebraic[9] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) - algebraic[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) - algebraic[38] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) - algebraic[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) - algebraic[40] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) - algebraic[42] = 0.6*states[12]+0.4*states[11] - algebraic[8] = computed_constants[18]*algebraic[42]*states[10]*(states[0]-computed_constants[6]) - algebraic[44] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) - algebraic[43] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) - algebraic[46] = algebraic[44] - algebraic[45] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) - algebraic[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) - algebraic[7] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) - algebraic[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) - algebraic[48] = 1.0*exp(-states[0]/45.0) - algebraic[6] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) - algebraic[5] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) - algebraic[51] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) - algebraic[50] = 1.0*exp((states[0]+75.13)/21.25) +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[4] = computed_constants[3]*(states[0]-computed_constants[4]) + algebraicVariables[2] = computed_constants[5]*(states[0]-computed_constants[6]) + algebraicVariables[3] = computed_constants[7]*(states[0]-computed_constants[8]) + algebraicVariables[1] = computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) + algebraicVariables[0] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) + algebraicVariables[17] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[1], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 + algebraicVariables[14] = (1.0-algebraicVariables[17])*states[3]+algebraicVariables[17]*states[2] + algebraicVariables[13] = computed_constants[13]*pow(states[1], 3.0)*algebraicVariables[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] + algebraicVariables[16] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) + algebraicVariables[15] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 + algebraicVariables[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) + algebraicVariables[21] = algebraicVariables[19] + algebraicVariables[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 + algebraicVariables[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 + algebraicVariables[12] = computed_constants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) + algebraicVariables[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) + algebraicVariables[25] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[1], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) + algebraicVariables[22] = 2.0/(algebraicVariables[24]+algebraicVariables[25]) + algebraicVariables[23] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) + algebraicVariables[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) + algebraicVariables[29] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) + algebraicVariables[26] = (1.2-0.2*computed_constants[0])/(algebraicVariables[28]+algebraicVariables[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraicVariables[28]+algebraicVariables[29]) + algebraicVariables[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) + algebraicVariables[11] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) + algebraicVariables[32] = 1068.0*exp((states[0]+26.3)/30.0) + algebraicVariables[33] = 1068.0*exp(-(states[0]+26.3)/30.0) + algebraicVariables[30] = 1.0/(algebraicVariables[32]+algebraicVariables[33]) + algebraicVariables[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) + algebraicVariables[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) + algebraicVariables[37] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[1], 1.0) else 15.0*exp((states[0]+71.7)/15.38) + algebraicVariables[34] = 1.0/(algebraicVariables[36]+algebraicVariables[37]) + algebraicVariables[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) + algebraicVariables[10] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) + algebraicVariables[9] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) + algebraicVariables[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) + algebraicVariables[38] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) + algebraicVariables[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) + algebraicVariables[40] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) + algebraicVariables[42] = 0.6*states[12]+0.4*states[11] + algebraicVariables[8] = computed_constants[18]*algebraicVariables[42]*states[10]*(states[0]-computed_constants[6]) + algebraicVariables[44] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) + algebraicVariables[43] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) + algebraicVariables[46] = algebraicVariables[44] + algebraicVariables[45] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) + algebraicVariables[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) + algebraicVariables[7] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) + algebraicVariables[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) + algebraicVariables[48] = 1.0*exp(-states[0]/45.0) + algebraicVariables[6] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) + algebraicVariables[5] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) + algebraicVariables[51] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) + algebraicVariables[50] = 1.0*exp((states[0]+75.13)/21.25) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 57bd1e9b3..d62e741c3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_COUNT = 9; -const size_t EXTERNAL_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 9; +const size_t EXTERNAL_VARIABLE_COUNT = 1; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -86,22 +86,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; @@ -133,34 +133,34 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[0] = constants[2]*(states[0]-computedConstants[0]); - algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; - algebraic[4] = 4.0*exp(states[0]/18.0); - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2]; - algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[5] = 0.07*exp(states[0]/20.0); - rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1]; - algebraic[8] = 0.125*exp(states[0]/80.0); - algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = algebraic[7]*(1.0-states[3])-algebraic[8]*states[3]; + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = constants[2]*(states[0]-computedConstants[0]); + algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-externalVariables[0]+algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0])/constants[0]; + algebraicVariables[4] = 4.0*exp(states[0]/18.0); + algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + rates[2] = algebraicVariables[3]*(1.0-states[2])-algebraicVariables[4]*states[2]; + algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[5] = 0.07*exp(states[0]/20.0); + rates[1] = algebraicVariables[5]*(1.0-states[1])-algebraicVariables[6]*states[1]; + algebraicVariables[8] = 0.125*exp(states[0]/80.0); + algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraicVariables[7]*(1.0-states[3])-algebraicVariables[8]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[0] = constants[2]*(states[0]-computedConstants[0]); - algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[4] = 4.0*exp(states[0]/18.0); - algebraic[5] = 0.07*exp(states[0]/20.0); - algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[8] = 0.125*exp(states[0]/80.0); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = constants[2]*(states[0]-computedConstants[0]); + algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraicVariables[4] = 4.0*exp(states[0]/18.0); + algebraicVariables[5] = 0.07*exp(states[0]/20.0); + algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraicVariables[8] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index d6171fd1a..03a57c1b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[8]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index f4db29b48..269ccdff7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -10,8 +10,8 @@ STATE_COUNT = 4 CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_COUNT = 9 -EXTERNAL_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 9 +EXTERNAL_VARIABLE_COUNT = 1 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -77,15 +77,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -103,31 +103,31 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[0] = constants[2]*(states[0]-computed_constants[0]) - algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0] - algebraic[4] = 4.0*exp(states[0]/18.0) - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2] - algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[5] = 0.07*exp(states[0]/20.0) - rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1] - algebraic[8] = 0.125*exp(states[0]/80.0) - algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = algebraic[7]*(1.0-states[3])-algebraic[8]*states[3] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[0] = constants[2]*(states[0]-computed_constants[0]) - algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[4] = 4.0*exp(states[0]/18.0) - algebraic[5] = 0.07*exp(states[0]/20.0) - algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[8] = 0.125*exp(states[0]/80.0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[0] = constants[2]*(states[0]-computed_constants[0]) + algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-externalVariables[0]+algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0])/constants[0] + algebraicVariables[4] = 4.0*exp(states[0]/18.0) + algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + rates[2] = algebraicVariables[3]*(1.0-states[2])-algebraicVariables[4]*states[2] + algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[5] = 0.07*exp(states[0]/20.0) + rates[1] = algebraicVariables[5]*(1.0-states[1])-algebraicVariables[6]*states[1] + algebraicVariables[8] = 0.125*exp(states[0]/80.0) + algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraicVariables[7]*(1.0-states[3])-algebraicVariables[8]*states[3] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[0] = constants[2]*(states[0]-computed_constants[0]) + algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraicVariables[4] = 4.0*exp(states[0]/18.0) + algebraicVariables[5] = 0.07*exp(states[0]/20.0) + algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraicVariables[8] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 20f5f4984..cdffa09a4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_COUNT = 10; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -82,11 +82,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -98,7 +98,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; @@ -118,33 +118,33 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[5] = 4.0*exp(states[0]/18.0); - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[9] = 0.125*exp(states[0]/80.0); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0]; + algebraicVariables[5] = 4.0*exp(states[0]/18.0); + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1]; + algebraicVariables[9] = 0.125*exp(states[0]/80.0); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraicVariables[8]*(1.0-states[3])-algebraicVariables[9]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[5] = 4.0*exp(states[0]/18.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[9] = 0.125*exp(states[0]/80.0); + algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); + algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraicVariables[5] = 4.0*exp(states[0]/18.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraicVariables[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 99dc6070b..6a45ce5c8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 2; -const size_t ALGEBRAIC_COUNT = 10; -const size_t EXTERNAL_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; +const size_t EXTERNAL_VARIABLE_COUNT = 1; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -86,22 +86,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; @@ -132,35 +132,35 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[1] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[1] = constants[2]*(states[0]-externals[0]); - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[5] = 4.0*exp(states[0]/18.0); - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[9] = 0.125*exp(states[0]/80.0); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[1] = constants[2]*(states[0]-externalVariables[0]); + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); + algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0]; + algebraicVariables[5] = 4.0*exp(states[0]/18.0); + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1]; + algebraicVariables[9] = 0.125*exp(states[0]/80.0); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraicVariables[8]*(1.0-states[3])-algebraicVariables[9]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[1] = constants[2]*(states[0]-externals[0]); - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[5] = 4.0*exp(states[0]/18.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[9] = 0.125*exp(states[0]/80.0); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[1] = constants[2]*(states[0]-externalVariables[0]); + algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraicVariables[5] = 4.0*exp(states[0]/18.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraicVariables[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index d6171fd1a..03a57c1b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[8]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index ed84c115a..a9da5eb92 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -10,8 +10,8 @@ STATE_COUNT = 4 CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 2 -ALGEBRAIC_COUNT = 10 -EXTERNAL_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 10 +EXTERNAL_VARIABLE_COUNT = 1 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -77,15 +77,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -102,32 +102,32 @@ def compute_computed_constants(constants, computed_constants): computed_constants[1] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[1] = constants[2]*(states[0]-externals[0]) - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[5] = 4.0*exp(states[0]/18.0) - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[9] = 0.125*exp(states[0]/80.0) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[1] = constants[2]*(states[0]-externals[0]) - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[5] = 4.0*exp(states[0]/18.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[9] = 0.125*exp(states[0]/80.0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraicVariables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[1] = constants[2]*(states[0]-externalVariables[0]) + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) + algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0] + algebraicVariables[5] = 4.0*exp(states[0]/18.0) + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2] + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[6] = 0.07*exp(states[0]/20.0) + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1] + algebraicVariables[9] = 0.125*exp(states[0]/80.0) + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraicVariables[8]*(1.0-states[3])-algebraicVariables[9]*states[3] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[1] = constants[2]*(states[0]-externalVariables[0]) + algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraicVariables[5] = 4.0*exp(states[0]/18.0) + algebraicVariables[6] = 0.07*exp(states[0]/20.0) + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraicVariables[9] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index e5a9fe969..2eb4c0918 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 4; const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_COUNT = 10; -const size_t EXTERNAL_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; +const size_t EXTERNAL_VARIABLE_COUNT = 1; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -86,22 +86,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; @@ -132,35 +132,35 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[0]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[1] = constants[1]*(states[0]-computedConstants[0]); - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0]; - algebraic[5] = 4.0*exp(states[0]/18.0); - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[9] = 0.125*exp(states[0]/80.0); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[1] = constants[1]*(states[0]-computedConstants[0]); + algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/externalVariables[0]; + algebraicVariables[5] = 4.0*exp(states[0]/18.0); + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1]; + algebraicVariables[9] = 0.125*exp(states[0]/80.0); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraicVariables[8]*(1.0-states[3])-algebraicVariables[9]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraic[1] = constants[1]*(states[0]-computedConstants[0]); - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[5] = 4.0*exp(states[0]/18.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[9] = 0.125*exp(states[0]/80.0); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); + algebraicVariables[1] = constants[1]*(states[0]-computedConstants[0]); + algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraicVariables[5] = 4.0*exp(states[0]/18.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraicVariables[9] = 0.125*exp(states[0]/80.0); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index d6171fd1a..03a57c1b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[8]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 1352b3614..23c0e7ad8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -10,8 +10,8 @@ STATE_COUNT = 4 CONSTANT_COUNT = 4 COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_COUNT = 10 -EXTERNAL_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 10 +EXTERNAL_VARIABLE_COUNT = 1 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -77,15 +77,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -102,32 +102,32 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[0]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[1] = constants[1]*(states[0]-computed_constants[0]) - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0] - algebraic[5] = 4.0*exp(states[0]/18.0) - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[9] = 0.125*exp(states[0]/80.0) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - algebraic[1] = constants[1]*(states[0]-computed_constants[0]) - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[5] = 4.0*exp(states[0]/18.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[9] = 0.125*exp(states[0]/80.0) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraicVariables[1] = constants[1]*(states[0]-computed_constants[0]) + algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/externalVariables[0] + algebraicVariables[5] = 4.0*exp(states[0]/18.0) + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2] + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[6] = 0.07*exp(states[0]/20.0) + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1] + algebraicVariables[9] = 0.125*exp(states[0]/80.0) + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraicVariables[8]*(1.0-states[3])-algebraicVariables[9]*states[3] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraicVariables[1] = constants[1]*(states[0]-computed_constants[0]) + algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraicVariables[5] = 4.0*exp(states[0]/18.0) + algebraicVariables[6] = 0.07*exp(states[0]/20.0) + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraicVariables[9] = 0.125*exp(states[0]/80.0) + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 88b12957e..8c082c2dc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 13; +const size_t ALGEBRAIC_VARIABLE_COUNT = 13; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -82,11 +82,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -104,7 +104,7 @@ typedef struct { double *rates; double *constants; double *computedConstants; - double *algebraic; + double *algebraicVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -117,23 +117,23 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; - f[0] = algebraic[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; + f[0] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[0]; + u[0] = algebraicVariables[0]; nlaSolve(objectiveFunction0, u, 1, &rfi); - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; } void objectiveFunction1(double *u, double *f, void *data) @@ -143,16 +143,16 @@ void objectiveFunction1(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; rates[0] = u[0]; - f[0] = rates[0]-(-(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0])-0.0; + f[0] = rates[0]-(-(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0])-0.0; } -void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; u[0] = rates[0]; @@ -169,23 +169,23 @@ void objectiveFunction2(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[4] = u[0]; + algebraicVariables[4] = u[0]; - f[0] = algebraic[4]-(constants[1]-10.613)-0.0; + f[0] = algebraicVariables[4]-(constants[1]-10.613)-0.0; } -void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[4]; + u[0] = algebraicVariables[4]; nlaSolve(objectiveFunction2, u, 1, &rfi); - algebraic[4] = u[0]; + algebraicVariables[4] = u[0]; } void objectiveFunction3(double *u, double *f, void *data) @@ -195,23 +195,23 @@ void objectiveFunction3(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[1] = u[0]; + algebraicVariables[1] = u[0]; - f[0] = algebraic[1]-constants[2]*(states[0]-algebraic[4])-0.0; + f[0] = algebraicVariables[1]-constants[2]*(states[0]-algebraicVariables[4])-0.0; } -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[1]; + u[0] = algebraicVariables[1]; nlaSolve(objectiveFunction3, u, 1, &rfi); - algebraic[1] = u[0]; + algebraicVariables[1] = u[0]; } void objectiveFunction4(double *u, double *f, void *data) @@ -221,23 +221,23 @@ void objectiveFunction4(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[5] = u[0]; + algebraicVariables[5] = u[0]; - f[0] = algebraic[5]-(constants[1]-115.0)-0.0; + f[0] = algebraicVariables[5]-(constants[1]-115.0)-0.0; } -void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[5]; + u[0] = algebraicVariables[5]; nlaSolve(objectiveFunction4, u, 1, &rfi); - algebraic[5] = u[0]; + algebraicVariables[5] = u[0]; } void objectiveFunction5(double *u, double *f, void *data) @@ -247,23 +247,23 @@ void objectiveFunction5(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[3] = u[0]; + algebraicVariables[3] = u[0]; - f[0] = algebraic[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5])-0.0; + f[0] = algebraicVariables[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5])-0.0; } -void findRoot5(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot5(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[3]; + u[0] = algebraicVariables[3]; nlaSolve(objectiveFunction5, u, 1, &rfi); - algebraic[3] = u[0]; + algebraicVariables[3] = u[0]; } void objectiveFunction6(double *u, double *f, void *data) @@ -273,23 +273,23 @@ void objectiveFunction6(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[6] = u[0]; + algebraicVariables[6] = u[0]; - f[0] = algebraic[6]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0; + f[0] = algebraicVariables[6]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0; } -void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[6]; + u[0] = algebraicVariables[6]; nlaSolve(objectiveFunction6, u, 1, &rfi); - algebraic[6] = u[0]; + algebraicVariables[6] = u[0]; } void objectiveFunction7(double *u, double *f, void *data) @@ -299,23 +299,23 @@ void objectiveFunction7(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[7] = u[0]; + algebraicVariables[7] = u[0]; - f[0] = algebraic[7]-4.0*exp(states[0]/18.0)-0.0; + f[0] = algebraicVariables[7]-4.0*exp(states[0]/18.0)-0.0; } -void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[7]; + u[0] = algebraicVariables[7]; nlaSolve(objectiveFunction7, u, 1, &rfi); - algebraic[7] = u[0]; + algebraicVariables[7] = u[0]; } void objectiveFunction8(double *u, double *f, void *data) @@ -325,16 +325,16 @@ void objectiveFunction8(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; rates[2] = u[0]; - f[0] = rates[2]-(algebraic[6]*(1.0-states[2])-algebraic[7]*states[2])-0.0; + f[0] = rates[2]-(algebraicVariables[6]*(1.0-states[2])-algebraicVariables[7]*states[2])-0.0; } -void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; u[0] = rates[2]; @@ -351,23 +351,23 @@ void objectiveFunction9(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[8] = u[0]; + algebraicVariables[8] = u[0]; - f[0] = algebraic[8]-0.07*exp(states[0]/20.0)-0.0; + f[0] = algebraicVariables[8]-0.07*exp(states[0]/20.0)-0.0; } -void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[8]; + u[0] = algebraicVariables[8]; nlaSolve(objectiveFunction9, u, 1, &rfi); - algebraic[8] = u[0]; + algebraicVariables[8] = u[0]; } void objectiveFunction10(double *u, double *f, void *data) @@ -377,23 +377,23 @@ void objectiveFunction10(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[9] = u[0]; + algebraicVariables[9] = u[0]; - f[0] = algebraic[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; + f[0] = algebraicVariables[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0; } -void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[9]; + u[0] = algebraicVariables[9]; nlaSolve(objectiveFunction10, u, 1, &rfi); - algebraic[9] = u[0]; + algebraicVariables[9] = u[0]; } void objectiveFunction11(double *u, double *f, void *data) @@ -403,16 +403,16 @@ void objectiveFunction11(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; rates[1] = u[0]; - f[0] = rates[1]-(algebraic[8]*(1.0-states[1])-algebraic[9]*states[1])-0.0; + f[0] = rates[1]-(algebraicVariables[8]*(1.0-states[1])-algebraicVariables[9]*states[1])-0.0; } -void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; u[0] = rates[1]; @@ -429,23 +429,23 @@ void objectiveFunction12(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[10] = u[0]; + algebraicVariables[10] = u[0]; - f[0] = algebraic[10]-(constants[1]+12.0)-0.0; + f[0] = algebraicVariables[10]-(constants[1]+12.0)-0.0; } -void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[10]; + u[0] = algebraicVariables[10]; nlaSolve(objectiveFunction12, u, 1, &rfi); - algebraic[10] = u[0]; + algebraicVariables[10] = u[0]; } void objectiveFunction13(double *u, double *f, void *data) @@ -455,23 +455,23 @@ void objectiveFunction13(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[2] = u[0]; + algebraicVariables[2] = u[0]; - f[0] = algebraic[2]-constants[4]*pow(states[3], 4.0)*(states[0]-algebraic[10])-0.0; + f[0] = algebraicVariables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-algebraicVariables[10])-0.0; } -void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[2]; + u[0] = algebraicVariables[2]; nlaSolve(objectiveFunction13, u, 1, &rfi); - algebraic[2] = u[0]; + algebraicVariables[2] = u[0]; } void objectiveFunction14(double *u, double *f, void *data) @@ -481,23 +481,23 @@ void objectiveFunction14(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[11] = u[0]; + algebraicVariables[11] = u[0]; - f[0] = algebraic[11]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; + f[0] = algebraicVariables[11]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0; } -void findRoot14(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot14(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[11]; + u[0] = algebraicVariables[11]; nlaSolve(objectiveFunction14, u, 1, &rfi); - algebraic[11] = u[0]; + algebraicVariables[11] = u[0]; } void objectiveFunction15(double *u, double *f, void *data) @@ -507,23 +507,23 @@ void objectiveFunction15(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[12] = u[0]; + algebraicVariables[12] = u[0]; - f[0] = algebraic[12]-0.125*exp(states[0]/80.0)-0.0; + f[0] = algebraicVariables[12]-0.125*exp(states[0]/80.0)-0.0; } -void findRoot15(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot15(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[12]; + u[0] = algebraicVariables[12]; nlaSolve(objectiveFunction15, u, 1, &rfi); - algebraic[12] = u[0]; + algebraicVariables[12] = u[0]; } void objectiveFunction16(double *u, double *f, void *data) @@ -533,16 +533,16 @@ void objectiveFunction16(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; rates[3] = u[0]; - f[0] = rates[3]-(algebraic[11]*(1.0-states[3])-algebraic[12]*states[3])-0.0; + f[0] = rates[3]-(algebraicVariables[11]*(1.0-states[3])-algebraicVariables[12]*states[3])-0.0; } -void findRoot16(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot16(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; u[0] = rates[3]; @@ -552,7 +552,7 @@ void findRoot16(double voi, double *states, double *rates, double *constants, do rates[3] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; @@ -567,63 +567,63 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - algebraic[0] = 0.0; - algebraic[1] = 0.0; - algebraic[2] = 0.0; - algebraic[3] = 0.0; - algebraic[4] = 0.0; - algebraic[5] = 0.0; - algebraic[6] = 0.0; - algebraic[7] = 0.0; - algebraic[8] = 0.0; - algebraic[9] = 0.0; - algebraic[10] = 0.0; - algebraic[11] = 0.0; - algebraic[12] = 0.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; + algebraicVariables[2] = 0.0; + algebraicVariables[3] = 0.0; + algebraicVariables[4] = 0.0; + algebraicVariables[5] = 0.0; + algebraicVariables[6] = 0.0; + algebraicVariables[7] = 0.0; + algebraicVariables[8] = 0.0; + algebraicVariables[9] = 0.0; + algebraicVariables[10] = 0.0; + algebraicVariables[11] = 0.0; + algebraicVariables[12] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraic); - findRoot2(voi, states, rates, constants, computedConstants, algebraic); - findRoot3(voi, states, rates, constants, computedConstants, algebraic); - findRoot15(voi, states, rates, constants, computedConstants, algebraic); - findRoot14(voi, states, rates, constants, computedConstants, algebraic); - findRoot16(voi, states, rates, constants, computedConstants, algebraic); - findRoot12(voi, states, rates, constants, computedConstants, algebraic); - findRoot13(voi, states, rates, constants, computedConstants, algebraic); - findRoot10(voi, states, rates, constants, computedConstants, algebraic); - findRoot9(voi, states, rates, constants, computedConstants, algebraic); - findRoot11(voi, states, rates, constants, computedConstants, algebraic); - findRoot7(voi, states, rates, constants, computedConstants, algebraic); - findRoot6(voi, states, rates, constants, computedConstants, algebraic); - findRoot8(voi, states, rates, constants, computedConstants, algebraic); - findRoot4(voi, states, rates, constants, computedConstants, algebraic); - findRoot5(voi, states, rates, constants, computedConstants, algebraic); - findRoot1(voi, states, rates, constants, computedConstants, algebraic); -} - -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) -{ - findRoot0(voi, states, rates, constants, computedConstants, algebraic); - findRoot2(voi, states, rates, constants, computedConstants, algebraic); - findRoot3(voi, states, rates, constants, computedConstants, algebraic); - findRoot15(voi, states, rates, constants, computedConstants, algebraic); - findRoot14(voi, states, rates, constants, computedConstants, algebraic); - findRoot16(voi, states, rates, constants, computedConstants, algebraic); - findRoot12(voi, states, rates, constants, computedConstants, algebraic); - findRoot13(voi, states, rates, constants, computedConstants, algebraic); - findRoot10(voi, states, rates, constants, computedConstants, algebraic); - findRoot9(voi, states, rates, constants, computedConstants, algebraic); - findRoot11(voi, states, rates, constants, computedConstants, algebraic); - findRoot7(voi, states, rates, constants, computedConstants, algebraic); - findRoot6(voi, states, rates, constants, computedConstants, algebraic); - findRoot8(voi, states, rates, constants, computedConstants, algebraic); - findRoot4(voi, states, rates, constants, computedConstants, algebraic); - findRoot5(voi, states, rates, constants, computedConstants, algebraic); - findRoot1(voi, states, rates, constants, computedConstants, algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot15(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot16(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot15(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot16(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c index 58b1f19bd..336e0410b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 11; -const size_t EXTERNAL_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 11; +const size_t EXTERNAL_VARIABLE_COUNT = 3; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -86,22 +86,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -119,8 +119,8 @@ typedef struct { double *rates; double *constants; double *computedConstants; - double *algebraic; - double *externals; + double *algebraicVariables; + double *externalVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -133,24 +133,24 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; - f[0] = algebraic[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; + f[0] = algebraicVariables[0]-(((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0)-0.0; } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[0]; + u[0] = algebraicVariables[0]; nlaSolve(objectiveFunction0, u, 1, &rfi); - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; } void objectiveFunction2(double *u, double *f, void *data) @@ -160,24 +160,24 @@ void objectiveFunction2(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[3] = u[0]; + algebraicVariables[3] = u[0]; - f[0] = algebraic[3]-(constants[1]-10.613)-0.0; + f[0] = algebraicVariables[3]-(constants[1]-10.613)-0.0; } -void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[3]; + u[0] = algebraicVariables[3]; nlaSolve(objectiveFunction2, u, 1, &rfi); - algebraic[3] = u[0]; + algebraicVariables[3] = u[0]; } void objectiveFunction3(double *u, double *f, void *data) @@ -187,24 +187,24 @@ void objectiveFunction3(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[1] = u[0]; + algebraicVariables[1] = u[0]; - f[0] = algebraic[1]-constants[2]*(externals[1]-algebraic[3])-0.0; + f[0] = algebraicVariables[1]-constants[2]*(externalVariables[1]-algebraicVariables[3])-0.0; } -void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[1]; + u[0] = algebraicVariables[1]; nlaSolve(objectiveFunction3, u, 1, &rfi); - algebraic[1] = u[0]; + algebraicVariables[1] = u[0]; } void objectiveFunction4(double *u, double *f, void *data) @@ -214,24 +214,24 @@ void objectiveFunction4(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[4] = u[0]; + algebraicVariables[4] = u[0]; - f[0] = algebraic[4]-(constants[1]-115.0)-0.0; + f[0] = algebraicVariables[4]-(constants[1]-115.0)-0.0; } -void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[4]; + u[0] = algebraicVariables[4]; nlaSolve(objectiveFunction4, u, 1, &rfi); - algebraic[4] = u[0]; + algebraicVariables[4] = u[0]; } void objectiveFunction6(double *u, double *f, void *data) @@ -241,24 +241,24 @@ void objectiveFunction6(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[5] = u[0]; + algebraicVariables[5] = u[0]; - f[0] = algebraic[5]-0.1*(externals[1]+25.0)/(exp((externals[1]+25.0)/10.0)-1.0)-0.0; + f[0] = algebraicVariables[5]-0.1*(externalVariables[1]+25.0)/(exp((externalVariables[1]+25.0)/10.0)-1.0)-0.0; } -void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[5]; + u[0] = algebraicVariables[5]; nlaSolve(objectiveFunction6, u, 1, &rfi); - algebraic[5] = u[0]; + algebraicVariables[5] = u[0]; } void objectiveFunction7(double *u, double *f, void *data) @@ -268,24 +268,24 @@ void objectiveFunction7(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[6] = u[0]; + algebraicVariables[6] = u[0]; - f[0] = algebraic[6]-4.0*exp(externals[1]/18.0)-0.0; + f[0] = algebraicVariables[6]-4.0*exp(externalVariables[1]/18.0)-0.0; } -void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[6]; + u[0] = algebraicVariables[6]; nlaSolve(objectiveFunction7, u, 1, &rfi); - algebraic[6] = u[0]; + algebraicVariables[6] = u[0]; } void objectiveFunction8(double *u, double *f, void *data) @@ -295,17 +295,17 @@ void objectiveFunction8(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; rates[1] = u[0]; - f[0] = rates[1]-(algebraic[5]*(1.0-states[1])-algebraic[6]*states[1])-0.0; + f[0] = rates[1]-(algebraicVariables[5]*(1.0-states[1])-algebraicVariables[6]*states[1])-0.0; } -void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; u[0] = rates[1]; @@ -322,24 +322,24 @@ void objectiveFunction9(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[7] = u[0]; + algebraicVariables[7] = u[0]; - f[0] = algebraic[7]-0.07*exp(externals[1]/20.0)-0.0; + f[0] = algebraicVariables[7]-0.07*exp(externalVariables[1]/20.0)-0.0; } -void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[7]; + u[0] = algebraicVariables[7]; nlaSolve(objectiveFunction9, u, 1, &rfi); - algebraic[7] = u[0]; + algebraicVariables[7] = u[0]; } void objectiveFunction10(double *u, double *f, void *data) @@ -349,24 +349,24 @@ void objectiveFunction10(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[8] = u[0]; + algebraicVariables[8] = u[0]; - f[0] = algebraic[8]-1.0/(exp((externals[1]+30.0)/10.0)+1.0)-0.0; + f[0] = algebraicVariables[8]-1.0/(exp((externalVariables[1]+30.0)/10.0)+1.0)-0.0; } -void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[8]; + u[0] = algebraicVariables[8]; nlaSolve(objectiveFunction10, u, 1, &rfi); - algebraic[8] = u[0]; + algebraicVariables[8] = u[0]; } void objectiveFunction11(double *u, double *f, void *data) @@ -376,17 +376,17 @@ void objectiveFunction11(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; rates[0] = u[0]; - f[0] = rates[0]-(algebraic[7]*(1.0-states[0])-algebraic[8]*states[0])-0.0; + f[0] = rates[0]-(algebraicVariables[7]*(1.0-states[0])-algebraicVariables[8]*states[0])-0.0; } -void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; u[0] = rates[0]; @@ -403,24 +403,24 @@ void objectiveFunction12(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[9] = u[0]; + algebraicVariables[9] = u[0]; - f[0] = algebraic[9]-(constants[1]+12.0)-0.0; + f[0] = algebraicVariables[9]-(constants[1]+12.0)-0.0; } -void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[9]; + u[0] = algebraicVariables[9]; nlaSolve(objectiveFunction12, u, 1, &rfi); - algebraic[9] = u[0]; + algebraicVariables[9] = u[0]; } void objectiveFunction13(double *u, double *f, void *data) @@ -430,24 +430,24 @@ void objectiveFunction13(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[2] = u[0]; + algebraicVariables[2] = u[0]; - f[0] = algebraic[2]-constants[4]*pow(states[2], 4.0)*(externals[1]-algebraic[9])-0.0; + f[0] = algebraicVariables[2]-constants[4]*pow(states[2], 4.0)*(externalVariables[1]-algebraicVariables[9])-0.0; } -void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[2]; + u[0] = algebraicVariables[2]; nlaSolve(objectiveFunction13, u, 1, &rfi); - algebraic[2] = u[0]; + algebraicVariables[2] = u[0]; } void objectiveFunction15(double *u, double *f, void *data) @@ -457,24 +457,24 @@ void objectiveFunction15(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; - algebraic[10] = u[0]; + algebraicVariables[10] = u[0]; - f[0] = algebraic[10]-0.125*exp(externals[1]/80.0)-0.0; + f[0] = algebraicVariables[10]-0.125*exp(externalVariables[1]/80.0)-0.0; } -void findRoot15(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot15(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; - u[0] = algebraic[10]; + u[0] = algebraicVariables[10]; nlaSolve(objectiveFunction15, u, 1, &rfi); - algebraic[10] = u[0]; + algebraicVariables[10] = u[0]; } void objectiveFunction16(double *u, double *f, void *data) @@ -484,17 +484,17 @@ void objectiveFunction16(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; - double *externals = ((RootFindingInfo *) data)->externals; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + double *externalVariables = ((RootFindingInfo *) data)->externalVariables; rates[2] = u[0]; - f[0] = rates[2]-(externals[2]*(1.0-states[2])-algebraic[10]*states[2])-0.0; + f[0] = rates[2]-(externalVariables[2]*(1.0-states[2])-algebraicVariables[10]*states[2])-0.0; } -void findRoot16(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals) +void findRoot16(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic, externals }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables }; double u[1]; u[0] = rates[2]; @@ -504,7 +504,7 @@ void findRoot16(double voi, double *states, double *rates, double *constants, do rates[2] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.6; states[1] = 0.05; @@ -517,46 +517,46 @@ void initialiseVariables(double *states, double *rates, double *constants, doubl constants[2] = 0.3; constants[3] = 120.0; constants[4] = 36.0; - algebraic[0] = 0.0; - algebraic[1] = 0.0; - algebraic[2] = 0.0; - algebraic[3] = 0.0; - algebraic[4] = 0.0; - algebraic[5] = 0.0; - algebraic[6] = 0.0; - algebraic[7] = 0.0; - algebraic[8] = 0.0; - algebraic[9] = 0.0; - algebraic[10] = 0.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; + algebraicVariables[2] = 0.0; + algebraicVariables[3] = 0.0; + algebraicVariables[4] = 0.0; + algebraicVariables[5] = 0.0; + algebraicVariables[6] = 0.0; + algebraicVariables[7] = 0.0; + algebraicVariables[8] = 0.0; + algebraicVariables[9] = 0.0; + algebraicVariables[10] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - findRoot7(voi, states, rates, constants, computedConstants, algebraic, externals); - findRoot6(voi, states, rates, constants, computedConstants, algebraic, externals); - findRoot8(voi, states, rates, constants, computedConstants, algebraic, externals); - findRoot10(voi, states, rates, constants, computedConstants, algebraic, externals); - findRoot9(voi, states, rates, constants, computedConstants, algebraic, externals); - findRoot11(voi, states, rates, constants, computedConstants, algebraic, externals); - findRoot15(voi, states, rates, constants, computedConstants, algebraic, externals); - externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); - findRoot16(voi, states, rates, constants, computedConstants, algebraic, externals); + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot15(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); + findRoot16(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - findRoot0(voi, states, rates, constants, computedConstants, algebraic, externals); - findRoot2(voi, states, rates, constants, computedConstants, algebraic, externals); - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - findRoot3(voi, states, rates, constants, computedConstants, algebraic, externals); - findRoot4(voi, states, rates, constants, computedConstants, algebraic, externals); - findRoot12(voi, states, rates, constants, computedConstants, algebraic, externals); - findRoot13(voi, states, rates, constants, computedConstants, algebraic, externals); - externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h index d6171fd1a..03a57c1b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[8]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py index bc720ae19..e139cb306 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py @@ -10,8 +10,8 @@ STATE_COUNT = 3 CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 11 -EXTERNAL_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 11 +EXTERNAL_VARIABLE_COUNT = 3 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -77,12 +77,12 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT from nlasolver import nla_solve @@ -94,22 +94,22 @@ def objective_function_0(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[0] = u[0] + algebraicVariables[0] = u[0] - f[0] = algebraic[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 + f[0] = algebraicVariables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 -def find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[0] + u[0] = algebraicVariables[0] - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[0] = u[0] + algebraicVariables[0] = u[0] def objective_function_2(u, f, data): @@ -118,22 +118,22 @@ def objective_function_2(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[3] = u[0] + algebraicVariables[3] = u[0] - f[0] = algebraic[3]-(constants[1]-10.613)-0.0 + f[0] = algebraicVariables[3]-(constants[1]-10.613)-0.0 -def find_root_2(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[3] + u[0] = algebraicVariables[3] - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[3] = u[0] + algebraicVariables[3] = u[0] def objective_function_3(u, f, data): @@ -142,22 +142,22 @@ def objective_function_3(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[1] = u[0] + algebraicVariables[1] = u[0] - f[0] = algebraic[1]-constants[2]*(externals[1]-algebraic[3])-0.0 + f[0] = algebraicVariables[1]-constants[2]*(externalVariables[1]-algebraicVariables[3])-0.0 -def find_root_3(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[1] + u[0] = algebraicVariables[1] - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[1] = u[0] + algebraicVariables[1] = u[0] def objective_function_4(u, f, data): @@ -166,22 +166,22 @@ def objective_function_4(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[4] = u[0] + algebraicVariables[4] = u[0] - f[0] = algebraic[4]-(constants[1]-115.0)-0.0 + f[0] = algebraicVariables[4]-(constants[1]-115.0)-0.0 -def find_root_4(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[4] + u[0] = algebraicVariables[4] - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[4] = u[0] + algebraicVariables[4] = u[0] def objective_function_6(u, f, data): @@ -190,22 +190,22 @@ def objective_function_6(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[5] = u[0] + algebraicVariables[5] = u[0] - f[0] = algebraic[5]-0.1*(externals[1]+25.0)/(exp((externals[1]+25.0)/10.0)-1.0)-0.0 + f[0] = algebraicVariables[5]-0.1*(externalVariables[1]+25.0)/(exp((externalVariables[1]+25.0)/10.0)-1.0)-0.0 -def find_root_6(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[5] + u[0] = algebraicVariables[5] - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[5] = u[0] + algebraicVariables[5] = u[0] def objective_function_7(u, f, data): @@ -214,22 +214,22 @@ def objective_function_7(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[6] = u[0] + algebraicVariables[6] = u[0] - f[0] = algebraic[6]-4.0*exp(externals[1]/18.0)-0.0 + f[0] = algebraicVariables[6]-4.0*exp(externalVariables[1]/18.0)-0.0 -def find_root_7(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[6] + u[0] = algebraicVariables[6] - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[6] = u[0] + algebraicVariables[6] = u[0] def objective_function_8(u, f, data): @@ -238,20 +238,20 @@ def objective_function_8(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] rates[1] = u[0] - f[0] = rates[1]-(algebraic[5]*(1.0-states[1])-algebraic[6]*states[1])-0.0 + f[0] = rates[1]-(algebraicVariables[5]*(1.0-states[1])-algebraicVariables[6]*states[1])-0.0 -def find_root_8(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 u[0] = rates[1] - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) rates[1] = u[0] @@ -262,22 +262,22 @@ def objective_function_9(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[7] = u[0] + algebraicVariables[7] = u[0] - f[0] = algebraic[7]-0.07*exp(externals[1]/20.0)-0.0 + f[0] = algebraicVariables[7]-0.07*exp(externalVariables[1]/20.0)-0.0 -def find_root_9(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[7] + u[0] = algebraicVariables[7] - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[7] = u[0] + algebraicVariables[7] = u[0] def objective_function_10(u, f, data): @@ -286,22 +286,22 @@ def objective_function_10(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[8] = u[0] + algebraicVariables[8] = u[0] - f[0] = algebraic[8]-1.0/(exp((externals[1]+30.0)/10.0)+1.0)-0.0 + f[0] = algebraicVariables[8]-1.0/(exp((externalVariables[1]+30.0)/10.0)+1.0)-0.0 -def find_root_10(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[8] + u[0] = algebraicVariables[8] - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[8] = u[0] + algebraicVariables[8] = u[0] def objective_function_11(u, f, data): @@ -310,20 +310,20 @@ def objective_function_11(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] rates[0] = u[0] - f[0] = rates[0]-(algebraic[7]*(1.0-states[0])-algebraic[8]*states[0])-0.0 + f[0] = rates[0]-(algebraicVariables[7]*(1.0-states[0])-algebraicVariables[8]*states[0])-0.0 -def find_root_11(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 u[0] = rates[0] - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) rates[0] = u[0] @@ -334,22 +334,22 @@ def objective_function_12(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[9] = u[0] + algebraicVariables[9] = u[0] - f[0] = algebraic[9]-(constants[1]+12.0)-0.0 + f[0] = algebraicVariables[9]-(constants[1]+12.0)-0.0 -def find_root_12(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[9] + u[0] = algebraicVariables[9] - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[9] = u[0] + algebraicVariables[9] = u[0] def objective_function_13(u, f, data): @@ -358,22 +358,22 @@ def objective_function_13(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[2] = u[0] + algebraicVariables[2] = u[0] - f[0] = algebraic[2]-constants[4]*pow(states[2], 4.0)*(externals[1]-algebraic[9])-0.0 + f[0] = algebraicVariables[2]-constants[4]*pow(states[2], 4.0)*(externalVariables[1]-algebraicVariables[9])-0.0 -def find_root_13(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[2] + u[0] = algebraicVariables[2] - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[2] = u[0] + algebraicVariables[2] = u[0] def objective_function_15(u, f, data): @@ -382,22 +382,22 @@ def objective_function_15(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] - algebraic[10] = u[0] + algebraicVariables[10] = u[0] - f[0] = algebraic[10]-0.125*exp(externals[1]/80.0)-0.0 + f[0] = algebraicVariables[10]-0.125*exp(externalVariables[1]/80.0)-0.0 -def find_root_15(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 - u[0] = algebraic[10] + u[0] = algebraicVariables[10] - u = nla_solve(objective_function_15, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_15, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) - algebraic[10] = u[0] + algebraicVariables[10] = u[0] def objective_function_16(u, f, data): @@ -406,25 +406,25 @@ def objective_function_16(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] - externals = data[6] + algebraic_variables = data[5] + external_variables = data[6] rates[2] = u[0] - f[0] = rates[2]-(externals[2]*(1.0-states[2])-algebraic[10]*states[2])-0.0 + f[0] = rates[2]-(externalVariables[2]*(1.0-states[2])-algebraicVariables[10]*states[2])-0.0 -def find_root_16(voi, states, rates, constants, computed_constants, algebraic, externals): +def find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables): u = [nan]*1 u[0] = rates[2] - u = nla_solve(objective_function_16, u, 1, [voi, states, rates, constants, computed_constants, algebraic, externals]) + u = nla_solve(objective_function_16, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables, external_variables]) rates[2] = u[0] -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.6 states[1] = 0.05 states[2] = 0.325 @@ -436,43 +436,43 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - algebraic[0] = 0.0 - algebraic[1] = 0.0 - algebraic[2] = 0.0 - algebraic[3] = 0.0 - algebraic[4] = 0.0 - algebraic[5] = 0.0 - algebraic[6] = 0.0 - algebraic[7] = 0.0 - algebraic[8] = 0.0 - algebraic[9] = 0.0 - algebraic[10] = 0.0 + algebraicVariables[0] = 0.0 + algebraicVariables[1] = 0.0 + algebraicVariables[2] = 0.0 + algebraicVariables[3] = 0.0 + algebraicVariables[4] = 0.0 + algebraicVariables[5] = 0.0 + algebraicVariables[6] = 0.0 + algebraicVariables[7] = 0.0 + algebraicVariables[8] = 0.0 + algebraicVariables[9] = 0.0 + algebraicVariables[10] = 0.0 def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - find_root_7(voi, states, rates, constants, computed_constants, algebraic, externals) - find_root_6(voi, states, rates, constants, computed_constants, algebraic, externals) - find_root_8(voi, states, rates, constants, computed_constants, algebraic, externals) - find_root_10(voi, states, rates, constants, computed_constants, algebraic, externals) - find_root_9(voi, states, rates, constants, computed_constants, algebraic, externals) - find_root_11(voi, states, rates, constants, computed_constants, algebraic, externals) - find_root_15(voi, states, rates, constants, computed_constants, algebraic, externals) - externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) - find_root_16(voi, states, rates, constants, computed_constants, algebraic, externals) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - find_root_0(voi, states, rates, constants, computed_constants, algebraic, externals) - find_root_2(voi, states, rates, constants, computed_constants, algebraic, externals) - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - find_root_3(voi, states, rates, constants, computed_constants, algebraic, externals) - find_root_4(voi, states, rates, constants, computed_constants, algebraic, externals) - find_root_12(voi, states, rates, constants, computed_constants, algebraic, externals) - find_root_13(voi, states, rates, constants, computed_constants, algebraic, externals) - externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + externalVariables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) + find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + externalVariables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + externalVariables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index 0019e3509..60d6aae86 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[8]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index b7305bef5..e2b90a51e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -10,7 +10,7 @@ STATE_COUNT = 4 CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 13 +ALGEBRAIC_VARIABLE_COUNT = 13 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -73,8 +73,8 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT from nlasolver import nla_solve @@ -86,21 +86,21 @@ def objective_function_0(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[0] = u[0] + algebraicVariables[0] = u[0] - f[0] = algebraic[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 + f[0] = algebraicVariables[0]-(-20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0)-0.0 -def find_root_0(voi, states, rates, constants, computed_constants, algebraic): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[0] + u[0] = algebraicVariables[0] - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[0] = u[0] + algebraicVariables[0] = u[0] def objective_function_1(u, f, data): @@ -109,19 +109,19 @@ def objective_function_1(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] rates[0] = u[0] - f[0] = rates[0]-(-(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0])-0.0 + f[0] = rates[0]-(-(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0])-0.0 -def find_root_1(voi, states, rates, constants, computed_constants, algebraic): +def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 u[0] = rates[0] - u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) rates[0] = u[0] @@ -132,21 +132,21 @@ def objective_function_2(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[4] = u[0] + algebraicVariables[4] = u[0] - f[0] = algebraic[4]-(constants[1]-10.613)-0.0 + f[0] = algebraicVariables[4]-(constants[1]-10.613)-0.0 -def find_root_2(voi, states, rates, constants, computed_constants, algebraic): +def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[4] + u[0] = algebraicVariables[4] - u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[4] = u[0] + algebraicVariables[4] = u[0] def objective_function_3(u, f, data): @@ -155,21 +155,21 @@ def objective_function_3(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[1] = u[0] + algebraicVariables[1] = u[0] - f[0] = algebraic[1]-constants[2]*(states[0]-algebraic[4])-0.0 + f[0] = algebraicVariables[1]-constants[2]*(states[0]-algebraicVariables[4])-0.0 -def find_root_3(voi, states, rates, constants, computed_constants, algebraic): +def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[1] + u[0] = algebraicVariables[1] - u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[1] = u[0] + algebraicVariables[1] = u[0] def objective_function_4(u, f, data): @@ -178,21 +178,21 @@ def objective_function_4(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[5] = u[0] + algebraicVariables[5] = u[0] - f[0] = algebraic[5]-(constants[1]-115.0)-0.0 + f[0] = algebraicVariables[5]-(constants[1]-115.0)-0.0 -def find_root_4(voi, states, rates, constants, computed_constants, algebraic): +def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[5] + u[0] = algebraicVariables[5] - u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[5] = u[0] + algebraicVariables[5] = u[0] def objective_function_5(u, f, data): @@ -201,21 +201,21 @@ def objective_function_5(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[3] = u[0] + algebraicVariables[3] = u[0] - f[0] = algebraic[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5])-0.0 + f[0] = algebraicVariables[3]-constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5])-0.0 -def find_root_5(voi, states, rates, constants, computed_constants, algebraic): +def find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[3] + u[0] = algebraicVariables[3] - u = nla_solve(objective_function_5, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_5, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[3] = u[0] + algebraicVariables[3] = u[0] def objective_function_6(u, f, data): @@ -224,21 +224,21 @@ def objective_function_6(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[6] = u[0] + algebraicVariables[6] = u[0] - f[0] = algebraic[6]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0 + f[0] = algebraicVariables[6]-0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0)-0.0 -def find_root_6(voi, states, rates, constants, computed_constants, algebraic): +def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[6] + u[0] = algebraicVariables[6] - u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[6] = u[0] + algebraicVariables[6] = u[0] def objective_function_7(u, f, data): @@ -247,21 +247,21 @@ def objective_function_7(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[7] = u[0] + algebraicVariables[7] = u[0] - f[0] = algebraic[7]-4.0*exp(states[0]/18.0)-0.0 + f[0] = algebraicVariables[7]-4.0*exp(states[0]/18.0)-0.0 -def find_root_7(voi, states, rates, constants, computed_constants, algebraic): +def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[7] + u[0] = algebraicVariables[7] - u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[7] = u[0] + algebraicVariables[7] = u[0] def objective_function_8(u, f, data): @@ -270,19 +270,19 @@ def objective_function_8(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] rates[2] = u[0] - f[0] = rates[2]-(algebraic[6]*(1.0-states[2])-algebraic[7]*states[2])-0.0 + f[0] = rates[2]-(algebraicVariables[6]*(1.0-states[2])-algebraicVariables[7]*states[2])-0.0 -def find_root_8(voi, states, rates, constants, computed_constants, algebraic): +def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 u[0] = rates[2] - u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) rates[2] = u[0] @@ -293,21 +293,21 @@ def objective_function_9(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[8] = u[0] + algebraicVariables[8] = u[0] - f[0] = algebraic[8]-0.07*exp(states[0]/20.0)-0.0 + f[0] = algebraicVariables[8]-0.07*exp(states[0]/20.0)-0.0 -def find_root_9(voi, states, rates, constants, computed_constants, algebraic): +def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[8] + u[0] = algebraicVariables[8] - u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[8] = u[0] + algebraicVariables[8] = u[0] def objective_function_10(u, f, data): @@ -316,21 +316,21 @@ def objective_function_10(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[9] = u[0] + algebraicVariables[9] = u[0] - f[0] = algebraic[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 + f[0] = algebraicVariables[9]-1.0/(exp((states[0]+30.0)/10.0)+1.0)-0.0 -def find_root_10(voi, states, rates, constants, computed_constants, algebraic): +def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[9] + u[0] = algebraicVariables[9] - u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[9] = u[0] + algebraicVariables[9] = u[0] def objective_function_11(u, f, data): @@ -339,19 +339,19 @@ def objective_function_11(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] rates[1] = u[0] - f[0] = rates[1]-(algebraic[8]*(1.0-states[1])-algebraic[9]*states[1])-0.0 + f[0] = rates[1]-(algebraicVariables[8]*(1.0-states[1])-algebraicVariables[9]*states[1])-0.0 -def find_root_11(voi, states, rates, constants, computed_constants, algebraic): +def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 u[0] = rates[1] - u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) rates[1] = u[0] @@ -362,21 +362,21 @@ def objective_function_12(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[10] = u[0] + algebraicVariables[10] = u[0] - f[0] = algebraic[10]-(constants[1]+12.0)-0.0 + f[0] = algebraicVariables[10]-(constants[1]+12.0)-0.0 -def find_root_12(voi, states, rates, constants, computed_constants, algebraic): +def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[10] + u[0] = algebraicVariables[10] - u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[10] = u[0] + algebraicVariables[10] = u[0] def objective_function_13(u, f, data): @@ -385,21 +385,21 @@ def objective_function_13(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[2] = u[0] + algebraicVariables[2] = u[0] - f[0] = algebraic[2]-constants[4]*pow(states[3], 4.0)*(states[0]-algebraic[10])-0.0 + f[0] = algebraicVariables[2]-constants[4]*pow(states[3], 4.0)*(states[0]-algebraicVariables[10])-0.0 -def find_root_13(voi, states, rates, constants, computed_constants, algebraic): +def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[2] + u[0] = algebraicVariables[2] - u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[2] = u[0] + algebraicVariables[2] = u[0] def objective_function_14(u, f, data): @@ -408,21 +408,21 @@ def objective_function_14(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[11] = u[0] + algebraicVariables[11] = u[0] - f[0] = algebraic[11]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 + f[0] = algebraicVariables[11]-0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0)-0.0 -def find_root_14(voi, states, rates, constants, computed_constants, algebraic): +def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[11] + u[0] = algebraicVariables[11] - u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[11] = u[0] + algebraicVariables[11] = u[0] def objective_function_15(u, f, data): @@ -431,21 +431,21 @@ def objective_function_15(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[12] = u[0] + algebraicVariables[12] = u[0] - f[0] = algebraic[12]-0.125*exp(states[0]/80.0)-0.0 + f[0] = algebraicVariables[12]-0.125*exp(states[0]/80.0)-0.0 -def find_root_15(voi, states, rates, constants, computed_constants, algebraic): +def find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[12] + u[0] = algebraicVariables[12] - u = nla_solve(objective_function_15, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_15, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[12] = u[0] + algebraicVariables[12] = u[0] def objective_function_16(u, f, data): @@ -454,24 +454,24 @@ def objective_function_16(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] rates[3] = u[0] - f[0] = rates[3]-(algebraic[11]*(1.0-states[3])-algebraic[12]*states[3])-0.0 + f[0] = rates[3]-(algebraicVariables[11]*(1.0-states[3])-algebraicVariables[12]*states[3])-0.0 -def find_root_16(voi, states, rates, constants, computed_constants, algebraic): +def find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 u[0] = rates[3] - u = nla_solve(objective_function_16, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_16, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) rates[3] = u[0] -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -485,60 +485,60 @@ def initialise_variables(states, rates, constants, computed_constants, algebraic constants[2] = 0.3 constants[3] = 120.0 constants[4] = 36.0 - algebraic[0] = 0.0 - algebraic[1] = 0.0 - algebraic[2] = 0.0 - algebraic[3] = 0.0 - algebraic[4] = 0.0 - algebraic[5] = 0.0 - algebraic[6] = 0.0 - algebraic[7] = 0.0 - algebraic[8] = 0.0 - algebraic[9] = 0.0 - algebraic[10] = 0.0 - algebraic[11] = 0.0 - algebraic[12] = 0.0 + algebraicVariables[0] = 0.0 + algebraicVariables[1] = 0.0 + algebraicVariables[2] = 0.0 + algebraicVariables[3] = 0.0 + algebraicVariables[4] = 0.0 + algebraicVariables[5] = 0.0 + algebraicVariables[6] = 0.0 + algebraicVariables[7] = 0.0 + algebraicVariables[8] = 0.0 + algebraicVariables[9] = 0.0 + algebraicVariables[10] = 0.0 + algebraicVariables[11] = 0.0 + algebraicVariables[12] = 0.0 def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - find_root_0(voi, states, rates, constants, computed_constants, algebraic) - find_root_2(voi, states, rates, constants, computed_constants, algebraic) - find_root_3(voi, states, rates, constants, computed_constants, algebraic) - find_root_15(voi, states, rates, constants, computed_constants, algebraic) - find_root_14(voi, states, rates, constants, computed_constants, algebraic) - find_root_16(voi, states, rates, constants, computed_constants, algebraic) - find_root_12(voi, states, rates, constants, computed_constants, algebraic) - find_root_13(voi, states, rates, constants, computed_constants, algebraic) - find_root_10(voi, states, rates, constants, computed_constants, algebraic) - find_root_9(voi, states, rates, constants, computed_constants, algebraic) - find_root_11(voi, states, rates, constants, computed_constants, algebraic) - find_root_7(voi, states, rates, constants, computed_constants, algebraic) - find_root_6(voi, states, rates, constants, computed_constants, algebraic) - find_root_8(voi, states, rates, constants, computed_constants, algebraic) - find_root_4(voi, states, rates, constants, computed_constants, algebraic) - find_root_5(voi, states, rates, constants, computed_constants, algebraic) - find_root_1(voi, states, rates, constants, computed_constants, algebraic) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - find_root_0(voi, states, rates, constants, computed_constants, algebraic) - find_root_2(voi, states, rates, constants, computed_constants, algebraic) - find_root_3(voi, states, rates, constants, computed_constants, algebraic) - find_root_15(voi, states, rates, constants, computed_constants, algebraic) - find_root_14(voi, states, rates, constants, computed_constants, algebraic) - find_root_16(voi, states, rates, constants, computed_constants, algebraic) - find_root_12(voi, states, rates, constants, computed_constants, algebraic) - find_root_13(voi, states, rates, constants, computed_constants, algebraic) - find_root_10(voi, states, rates, constants, computed_constants, algebraic) - find_root_9(voi, states, rates, constants, computed_constants, algebraic) - find_root_11(voi, states, rates, constants, computed_constants, algebraic) - find_root_7(voi, states, rates, constants, computed_constants, algebraic) - find_root_6(voi, states, rates, constants, computed_constants, algebraic) - find_root_8(voi, states, rates, constants, computed_constants, algebraic) - find_root_4(voi, states, rates, constants, computed_constants, algebraic) - find_root_5(voi, states, rates, constants, computed_constants, algebraic) - find_root_1(voi, states, rates, constants, computed_constants, algebraic) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index a6fb8af51..f42289959 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_COUNT = 8; -const size_t EXTERNAL_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 8; +const size_t EXTERNAL_VARIABLE_COUNT = 2; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -86,22 +86,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; @@ -133,34 +133,34 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[0] = constants[2]*(states[0]-computedConstants[0]); - algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; - algebraic[4] = 4.0*exp(states[0]/18.0); - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2]; - algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[5] = 0.07*exp(states[0]/20.0); - rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1]; - algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = algebraic[7]*(1.0-states[3])-externals[1]*states[3]; + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = constants[2]*(states[0]-computedConstants[0]); + algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-externalVariables[0]+algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0])/constants[0]; + algebraicVariables[4] = 4.0*exp(states[0]/18.0); + algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + rates[2] = algebraicVariables[3]*(1.0-states[2])-algebraicVariables[4]*states[2]; + algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[5] = 0.07*exp(states[0]/20.0); + rates[1] = algebraicVariables[5]*(1.0-states[1])-algebraicVariables[6]*states[1]; + algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraicVariables[7]*(1.0-states[3])-externalVariables[1]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[0] = constants[2]*(states[0]-computedConstants[0]); - algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[4] = 4.0*exp(states[0]/18.0); - algebraic[5] = 0.07*exp(states[0]/20.0); - algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = constants[2]*(states[0]-computedConstants[0]); + algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraicVariables[4] = 4.0*exp(states[0]/18.0); + algebraicVariables[5] = 0.07*exp(states[0]/20.0); + algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index d6171fd1a..03a57c1b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[8]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 6638e4592..5c0c635c5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -10,8 +10,8 @@ STATE_COUNT = 4 CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_COUNT = 8 -EXTERNAL_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 8 +EXTERNAL_VARIABLE_COUNT = 2 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -77,15 +77,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -103,31 +103,31 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[0] = constants[2]*(states[0]-computed_constants[0]) - algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-externals[0]+algebraic[2]+algebraic[1]+algebraic[0])/constants[0] - algebraic[4] = 4.0*exp(states[0]/18.0) - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - rates[2] = algebraic[3]*(1.0-states[2])-algebraic[4]*states[2] - algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[5] = 0.07*exp(states[0]/20.0) - rates[1] = algebraic[5]*(1.0-states[1])-algebraic[6]*states[1] - algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = algebraic[7]*(1.0-states[3])-externals[1]*states[3] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[0] = constants[2]*(states[0]-computed_constants[0]) - algebraic[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[4] = 4.0*exp(states[0]/18.0) - algebraic[5] = 0.07*exp(states[0]/20.0) - algebraic[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[0] = constants[2]*(states[0]-computed_constants[0]) + algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-externalVariables[0]+algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0])/constants[0] + algebraicVariables[4] = 4.0*exp(states[0]/18.0) + algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + rates[2] = algebraicVariables[3]*(1.0-states[2])-algebraicVariables[4]*states[2] + algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[5] = 0.07*exp(states[0]/20.0) + rates[1] = algebraicVariables[5]*(1.0-states[1])-algebraicVariables[6]*states[1] + algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraicVariables[7]*(1.0-states[3])-externalVariables[1]*states[3] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[0] = constants[2]*(states[0]-computed_constants[0]) + algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraicVariables[4] = 4.0*exp(states[0]/18.0) + algebraicVariables[5] = 0.07*exp(states[0]/20.0) + algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 78b3bd99c..3d4d1e641 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 4; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 12; -const size_t EXTERNAL_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 12; +const size_t EXTERNAL_VARIABLE_COUNT = 2; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -86,22 +86,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; @@ -129,41 +129,41 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[4] = externals[0]-10.613; - algebraic[1] = constants[1]*(states[0]-algebraic[4]); - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]); - algebraic[5] = externals[0]-115.0; - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[7] = 4.0*exp(states[0]/18.0); - algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2]; - algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[8] = 0.07*exp(states[0]/20.0); - rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1]; - algebraic[11] = 0.125*exp(states[0]/80.0); - algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = externalVariables[0]-10.613; + algebraicVariables[1] = constants[1]*(states[0]-algebraicVariables[4]); + algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externalVariables[1]); + algebraicVariables[5] = externalVariables[0]-115.0; + algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5]); + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0]; + algebraicVariables[7] = 4.0*exp(states[0]/18.0); + algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + rates[2] = algebraicVariables[6]*(1.0-states[2])-algebraicVariables[7]*states[2]; + algebraicVariables[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[8] = 0.07*exp(states[0]/20.0); + rates[1] = algebraicVariables[8]*(1.0-states[1])-algebraicVariables[9]*states[1]; + algebraicVariables[11] = 0.125*exp(states[0]/80.0); + algebraicVariables[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraicVariables[10]*(1.0-states[3])-algebraicVariables[11]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[4] = externals[0]-10.613; - algebraic[1] = constants[1]*(states[0]-algebraic[4]); - algebraic[5] = externals[0]-115.0; - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]); - algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[7] = 4.0*exp(states[0]/18.0); - algebraic[8] = 0.07*exp(states[0]/20.0); - algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]); - algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[11] = 0.125*exp(states[0]/80.0); + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[4] = externalVariables[0]-10.613; + algebraicVariables[1] = constants[1]*(states[0]-algebraicVariables[4]); + algebraicVariables[5] = externalVariables[0]-115.0; + algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5]); + algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraicVariables[7] = 4.0*exp(states[0]/18.0); + algebraicVariables[8] = 0.07*exp(states[0]/20.0); + algebraicVariables[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externalVariables[1]); + algebraicVariables[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraicVariables[11] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index d6171fd1a..03a57c1b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[8]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 8e963aa09..0057a9d4f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -10,8 +10,8 @@ STATE_COUNT = 4 CONSTANT_COUNT = 4 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 12 -EXTERNAL_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 12 +EXTERNAL_VARIABLE_COUNT = 2 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -77,15 +77,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -100,38 +100,38 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[4] = externals[0]-10.613 - algebraic[1] = constants[1]*(states[0]-algebraic[4]) - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]) - algebraic[5] = externals[0]-115.0 - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[7] = 4.0*exp(states[0]/18.0) - algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - rates[2] = algebraic[6]*(1.0-states[2])-algebraic[7]*states[2] - algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[8] = 0.07*exp(states[0]/20.0) - rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1] - algebraic[11] = 0.125*exp(states[0]/80.0) - algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[4] = externals[0]-10.613 - algebraic[1] = constants[1]*(states[0]-algebraic[4]) - algebraic[5] = externals[0]-115.0 - algebraic[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic[5]) - algebraic[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[7] = 4.0*exp(states[0]/18.0) - algebraic[8] = 0.07*exp(states[0]/20.0) - algebraic[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externals[1]) - algebraic[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[11] = 0.125*exp(states[0]/80.0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraicVariables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + externalVariables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[4] = externalVariables[0]-10.613 + algebraicVariables[1] = constants[1]*(states[0]-algebraicVariables[4]) + algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externalVariables[1]) + algebraicVariables[5] = externalVariables[0]-115.0 + algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5]) + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0] + algebraicVariables[7] = 4.0*exp(states[0]/18.0) + algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + rates[2] = algebraicVariables[6]*(1.0-states[2])-algebraicVariables[7]*states[2] + algebraicVariables[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[8] = 0.07*exp(states[0]/20.0) + rates[1] = algebraicVariables[8]*(1.0-states[1])-algebraicVariables[9]*states[1] + algebraicVariables[11] = 0.125*exp(states[0]/80.0) + algebraicVariables[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraicVariables[10]*(1.0-states[3])-algebraicVariables[11]*states[3] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[4] = externalVariables[0]-10.613 + algebraicVariables[1] = constants[1]*(states[0]-algebraicVariables[4]) + algebraicVariables[5] = externalVariables[0]-115.0 + algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5]) + algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraicVariables[7] = 4.0*exp(states[0]/18.0) + algebraicVariables[8] = 0.07*exp(states[0]/20.0) + algebraicVariables[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externalVariables[1]) + algebraicVariables[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraicVariables[11] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index a7c155dfb..313cb516d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 3; const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_COUNT = 10; -const size_t EXTERNAL_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; +const size_t EXTERNAL_VARIABLE_COUNT = 2; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -86,22 +86,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; @@ -131,37 +131,37 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[0]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[1] = constants[1]*(states[0]-computedConstants[0]); - algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0]; - algebraic[5] = 4.0*exp(states[0]/18.0); - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[9] = 0.125*exp(states[0]/80.0); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3]; + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[1] = constants[1]*(states[0]-computedConstants[0]); + algebraicVariables[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[3] = externalVariables[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/externalVariables[0]; + algebraicVariables[5] = 4.0*exp(states[0]/18.0); + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1]; + algebraicVariables[9] = 0.125*exp(states[0]/80.0); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[3] = algebraicVariables[8]*(1.0-states[3])-algebraicVariables[9]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraic[1] = constants[1]*(states[0]-computedConstants[0]); - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[5] = 4.0*exp(states[0]/18.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[9] = 0.125*exp(states[0]/80.0); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); + algebraicVariables[1] = constants[1]*(states[0]-computedConstants[0]); + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + algebraicVariables[3] = externalVariables[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraicVariables[5] = 4.0*exp(states[0]/18.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraicVariables[9] = 0.125*exp(states[0]/80.0); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index d6171fd1a..03a57c1b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[8]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 3e25d4379..8563cc59c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -10,8 +10,8 @@ STATE_COUNT = 4 CONSTANT_COUNT = 3 COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_COUNT = 10 -EXTERNAL_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 10 +EXTERNAL_VARIABLE_COUNT = 2 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -77,15 +77,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -101,34 +101,34 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[0]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[1] = constants[1]*(states[0]-computed_constants[0]) - algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/externals[0] - algebraic[5] = 4.0*exp(states[0]/18.0) - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[9] = 0.125*exp(states[0]/80.0) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - algebraic[1] = constants[1]*(states[0]-computed_constants[0]) - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - algebraic[3] = externals[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[5] = 4.0*exp(states[0]/18.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[9] = 0.125*exp(states[0]/80.0) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraicVariables[1] = constants[1]*(states[0]-computed_constants[0]) + algebraicVariables[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraicVariables[3] = externalVariables[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/externalVariables[0] + algebraicVariables[5] = 4.0*exp(states[0]/18.0) + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2] + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[6] = 0.07*exp(states[0]/20.0) + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1] + algebraicVariables[9] = 0.125*exp(states[0]/80.0) + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraicVariables[8]*(1.0-states[3])-algebraicVariables[9]*states[3] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraicVariables[1] = constants[1]*(states[0]-computed_constants[0]) + externalVariables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + algebraicVariables[3] = externalVariables[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraicVariables[5] = 4.0*exp(states[0]/18.0) + algebraicVariables[6] = 0.07*exp(states[0]/20.0) + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraicVariables[9] = 0.125*exp(states[0]/80.0) + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 7c8888dc4..e5d1dd95b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_COUNT = 10; -const size_t EXTERNAL_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; +const size_t EXTERNAL_VARIABLE_COUNT = 2; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -86,22 +86,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.6; states[1] = 0.325; @@ -131,25 +131,25 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[7] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0); - algebraic[6] = 0.07*exp(externals[0]/20.0); - rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0]; - algebraic[9] = 0.125*exp(externals[0]/80.0); - algebraic[8] = 0.01*(externals[0]+10.0)/(exp((externals[0]+10.0)/10.0)-1.0); - rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1]; + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[7] = 1.0/(exp((externalVariables[0]+30.0)/10.0)+1.0); + algebraicVariables[6] = 0.07*exp(externalVariables[0]/20.0); + rates[0] = algebraicVariables[6]*(1.0-states[0])-algebraicVariables[7]*states[0]; + algebraicVariables[9] = 0.125*exp(externalVariables[0]/80.0); + algebraicVariables[8] = 0.01*(externalVariables[0]+10.0)/(exp((externalVariables[0]+10.0)/10.0)-1.0); + rates[1] = algebraicVariables[8]*(1.0-states[1])-algebraicVariables[9]*states[1]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[1] = constants[2]*(externals[0]-computedConstants[0]); - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - algebraic[3] = constants[3]*pow(externals[1], 3.0)*states[0]*(externals[0]-computedConstants[1]); - algebraic[4] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0); - algebraic[5] = 4.0*exp(externals[0]/18.0); - algebraic[2] = constants[4]*pow(states[1], 4.0)*(externals[0]-computedConstants[2]); + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[1] = constants[2]*(externalVariables[0]-computedConstants[0]); + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + algebraicVariables[3] = constants[3]*pow(externalVariables[1], 3.0)*states[0]*(externalVariables[0]-computedConstants[1]); + algebraicVariables[4] = 0.1*(externalVariables[0]+25.0)/(exp((externalVariables[0]+25.0)/10.0)-1.0); + algebraicVariables[5] = 4.0*exp(externalVariables[0]/18.0); + algebraicVariables[2] = constants[4]*pow(states[1], 4.0)*(externalVariables[0]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index d6171fd1a..03a57c1b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[8]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 96d1a9ad3..80a764c9b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -10,8 +10,8 @@ STATE_COUNT = 2 CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_COUNT = 10 -EXTERNAL_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 10 +EXTERNAL_VARIABLE_COUNT = 2 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -77,15 +77,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.6 states[1] = 0.325 constants[0] = 1.0 @@ -101,22 +101,22 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[7] = 1.0/(exp((externals[0]+30.0)/10.0)+1.0) - algebraic[6] = 0.07*exp(externals[0]/20.0) - rates[0] = algebraic[6]*(1.0-states[0])-algebraic[7]*states[0] - algebraic[9] = 0.125*exp(externals[0]/80.0) - algebraic[8] = 0.01*(externals[0]+10.0)/(exp((externals[0]+10.0)/10.0)-1.0) - rates[1] = algebraic[8]*(1.0-states[1])-algebraic[9]*states[1] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[1] = constants[2]*(externals[0]-computed_constants[0]) - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - algebraic[3] = constants[3]*pow(externals[1], 3.0)*states[0]*(externals[0]-computed_constants[1]) - algebraic[4] = 0.1*(externals[0]+25.0)/(exp((externals[0]+25.0)/10.0)-1.0) - algebraic[5] = 4.0*exp(externals[0]/18.0) - algebraic[2] = constants[4]*pow(states[1], 4.0)*(externals[0]-computed_constants[2]) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[7] = 1.0/(exp((externalVariables[0]+30.0)/10.0)+1.0) + algebraicVariables[6] = 0.07*exp(externalVariables[0]/20.0) + rates[0] = algebraicVariables[6]*(1.0-states[0])-algebraicVariables[7]*states[0] + algebraicVariables[9] = 0.125*exp(externalVariables[0]/80.0) + algebraicVariables[8] = 0.01*(externalVariables[0]+10.0)/(exp((externalVariables[0]+10.0)/10.0)-1.0) + rates[1] = algebraicVariables[8]*(1.0-states[1])-algebraicVariables[9]*states[1] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraicVariables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[1] = constants[2]*(externalVariables[0]-computed_constants[0]) + externalVariables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + algebraicVariables[3] = constants[3]*pow(externalVariables[1], 3.0)*states[0]*(externalVariables[0]-computed_constants[1]) + algebraicVariables[4] = 0.1*(externalVariables[0]+25.0)/(exp((externalVariables[0]+25.0)/10.0)-1.0) + algebraicVariables[5] = 4.0*exp(externalVariables[0]/18.0) + algebraicVariables[2] = constants[4]*pow(states[1], 4.0)*(externalVariables[0]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 048289ae0..78967f2ea 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_COUNT = 8; -const size_t EXTERNAL_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 8; +const size_t EXTERNAL_VARIABLE_COUNT = 3; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -86,22 +86,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.6; states[1] = 0.05; @@ -132,26 +132,26 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - algebraic[4] = 4.0*exp(externals[1]/18.0); - algebraic[3] = 0.1*(externals[1]+25.0)/(exp((externals[1]+25.0)/10.0)-1.0); - rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1]; - algebraic[6] = 1.0/(exp((externals[1]+30.0)/10.0)+1.0); - algebraic[5] = 0.07*exp(externals[1]/20.0); - rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0]; - algebraic[7] = 0.125*exp(externals[1]/80.0); - externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); - rates[2] = externals[2]*(1.0-states[2])-algebraic[7]*states[2]; + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + algebraicVariables[4] = 4.0*exp(externalVariables[1]/18.0); + algebraicVariables[3] = 0.1*(externalVariables[1]+25.0)/(exp((externalVariables[1]+25.0)/10.0)-1.0); + rates[1] = algebraicVariables[3]*(1.0-states[1])-algebraicVariables[4]*states[1]; + algebraicVariables[6] = 1.0/(exp((externalVariables[1]+30.0)/10.0)+1.0); + algebraicVariables[5] = 0.07*exp(externalVariables[1]/20.0); + rates[0] = algebraicVariables[5]*(1.0-states[0])-algebraicVariables[6]*states[0]; + algebraicVariables[7] = 0.125*exp(externalVariables[1]/80.0); + externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); + rates[2] = externalVariables[2]*(1.0-states[2])-algebraicVariables[7]*states[2]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externals[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 1); - algebraic[1] = constants[2]*(externals[1]-computedConstants[0]); - externals[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 2); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[1]-computedConstants[2]); + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); + algebraicVariables[1] = constants[2]*(externalVariables[1]-computedConstants[0]); + externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[2] = constants[4]*pow(states[2], 4.0)*(externalVariables[1]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index d6171fd1a..03a57c1b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[8]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 2e2867ca2..0bb06126a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -10,8 +10,8 @@ STATE_COUNT = 3 CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_COUNT = 8 -EXTERNAL_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 8 +EXTERNAL_VARIABLE_COUNT = 3 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -77,15 +77,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.6 states[1] = 0.05 states[2] = 0.325 @@ -102,23 +102,23 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - algebraic[4] = 4.0*exp(externals[1]/18.0) - algebraic[3] = 0.1*(externals[1]+25.0)/(exp((externals[1]+25.0)/10.0)-1.0) - rates[1] = algebraic[3]*(1.0-states[1])-algebraic[4]*states[1] - algebraic[6] = 1.0/(exp((externals[1]+30.0)/10.0)+1.0) - algebraic[5] = 0.07*exp(externals[1]/20.0) - rates[0] = algebraic[5]*(1.0-states[0])-algebraic[6]*states[0] - algebraic[7] = 0.125*exp(externals[1]/80.0) - externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) - rates[2] = externals[2]*(1.0-states[2])-algebraic[7]*states[2] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - externals[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 1) - algebraic[1] = constants[2]*(externals[1]-computed_constants[0]) - externals[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 2) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[2] = constants[4]*pow(states[2], 4.0)*(externals[1]-computed_constants[2]) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + algebraicVariables[4] = 4.0*exp(externalVariables[1]/18.0) + algebraicVariables[3] = 0.1*(externalVariables[1]+25.0)/(exp((externalVariables[1]+25.0)/10.0)-1.0) + rates[1] = algebraicVariables[3]*(1.0-states[1])-algebraicVariables[4]*states[1] + algebraicVariables[6] = 1.0/(exp((externalVariables[1]+30.0)/10.0)+1.0) + algebraicVariables[5] = 0.07*exp(externalVariables[1]/20.0) + rates[0] = algebraicVariables[5]*(1.0-states[0])-algebraicVariables[6]*states[0] + algebraicVariables[7] = 0.125*exp(externalVariables[1]/80.0) + externalVariables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) + rates[2] = externalVariables[2]*(1.0-states[2])-algebraicVariables[7]*states[2] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraicVariables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + externalVariables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) + algebraicVariables[1] = constants[2]*(externalVariables[1]-computed_constants[0]) + externalVariables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[2] = constants[4]*pow(states[2], 4.0)*(externalVariables[1]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index 0019e3509..60d6aae86 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[8]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index eddf909c6..10f53f996 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 4 CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_COUNT = 10 +ALGEBRAIC_VARIABLE_COUNT = 10 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -73,11 +73,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 @@ -95,30 +95,30 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[5] = 4.0*exp(states[0]/18.0) - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[9] = 0.125*exp(states[0]/80.0) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[3] = algebraic[8]*(1.0-states[3])-algebraic[9]*states[3] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - algebraic[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[5] = 4.0*exp(states[0]/18.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[9] = 0.125*exp(states[0]/80.0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraicVariables[1] = constants[2]*(states[0]-computed_constants[0]) + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0] + algebraicVariables[5] = 4.0*exp(states[0]/18.0) + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2] + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[6] = 0.07*exp(states[0]/20.0) + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1] + algebraicVariables[9] = 0.125*exp(states[0]/80.0) + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[3] = algebraicVariables[8]*(1.0-states[3])-algebraicVariables[9]*states[3] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[1] = constants[2]*(states[0]-computed_constants[0]) + algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraicVariables[5] = 4.0*exp(states[0]/18.0) + algebraicVariables[6] = 0.07*exp(states[0]/20.0) + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraicVariables[9] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 976f72c4b..0ee5fa70b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -11,8 +11,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 3; -const size_t ALGEBRAIC_COUNT = 10; -const size_t EXTERNAL_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 10; +const size_t EXTERNAL_VARIABLE_COUNT = 1; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -86,22 +86,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; @@ -132,32 +132,32 @@ void computeComputedConstants(double *constants, double *computedConstants) computedConstants[2] = constants[1]+12.0; } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraic[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computedConstants[1]); - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0]; - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[9] = 0.125*exp(states[0]/80.0); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - rates[2] = algebraic[8]*(1.0-states[2])-algebraic[9]*states[2]; + algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; + algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); + algebraicVariables[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[3] = constants[3]*pow(externalVariables[0], 3.0)*states[1]*(states[0]-computedConstants[1]); + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0]; + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1]; + algebraicVariables[9] = 0.125*exp(states[0]/80.0); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + rates[2] = algebraicVariables[8]*(1.0-states[2])-algebraicVariables[9]*states[2]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraic[1] = constants[2]*(states[0]-computedConstants[0]); - externals[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraic, externals, 0); - algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraic[5] = 4.0*exp(states[0]/18.0); - algebraic[6] = 0.07*exp(states[0]/20.0); - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraic[9] = 0.125*exp(states[0]/80.0); + algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[3] = constants[3]*pow(externalVariables[0], 3.0)*states[1]*(states[0]-computedConstants[1]); + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + algebraicVariables[5] = 4.0*exp(states[0]/18.0); + algebraicVariables[6] = 0.07*exp(states[0]/20.0); + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); + algebraicVariables[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); + algebraicVariables[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index d6171fd1a..03a57c1b3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -10,8 +10,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[8]; @@ -29,14 +29,14 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 4b6c7b26c..9242260cd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -10,8 +10,8 @@ STATE_COUNT = 3 CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 3 -ALGEBRAIC_COUNT = 10 -EXTERNAL_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 10 +EXTERNAL_VARIABLE_COUNT = 1 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -77,15 +77,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.325 @@ -102,29 +102,29 @@ def compute_computed_constants(constants, computed_constants): computed_constants[2] = constants[1]+12.0 -def compute_rates(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - algebraic[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computed_constants[1]) - rates[0] = -(-algebraic[0]+algebraic[3]+algebraic[2]+algebraic[1])/constants[0] - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[9] = 0.125*exp(states[0]/80.0) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - rates[2] = algebraic[8]*(1.0-states[2])-algebraic[9]*states[2] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic, externals, external_variable): - algebraic[1] = constants[2]*(states[0]-computed_constants[0]) - externals[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic, externals, 0) - algebraic[3] = constants[3]*pow(externals[0], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic[5] = 4.0*exp(states[0]/18.0) - algebraic[6] = 0.07*exp(states[0]/20.0) - algebraic[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) - algebraic[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic[9] = 0.125*exp(states[0]/80.0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraicVariables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 + algebraicVariables[1] = constants[2]*(states[0]-computed_constants[0]) + algebraicVariables[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[3] = constants[3]*pow(externalVariables[0], 3.0)*states[1]*(states[0]-computed_constants[1]) + rates[0] = -(-algebraicVariables[0]+algebraicVariables[3]+algebraicVariables[2]+algebraicVariables[1])/constants[0] + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[6] = 0.07*exp(states[0]/20.0) + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1] + algebraicVariables[9] = 0.125*exp(states[0]/80.0) + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + rates[2] = algebraicVariables[8]*(1.0-states[2])-algebraicVariables[9]*states[2] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + algebraicVariables[1] = constants[2]*(states[0]-computed_constants[0]) + externalVariables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[3] = constants[3]*pow(externalVariables[0], 3.0)*states[1]*(states[0]-computed_constants[1]) + algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) + algebraicVariables[5] = 4.0*exp(states[0]/18.0) + algebraicVariables[6] = 0.07*exp(states[0]/20.0) + algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) + algebraicVariables[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) + algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + algebraicVariables[9] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 8fa658f0c..0ab3de18e 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; const size_t CONSTANT_COUNT = 5; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 12; +const size_t ALGEBRAIC_VARIABLE_COUNT = 12; const VariableInfo VOI_INFO = {"time", "millisecond", "environment"}; @@ -81,11 +81,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -97,7 +97,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = -87.0; states[1] = 0.8; @@ -114,38 +114,38 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = constants[2]*(states[0]-constants[1]); - algebraic[3] = pow(states[2], 3.0)*states[1]*constants[3]; - algebraic[2] = (algebraic[3]+0.14)*(states[0]-constants[4]); - algebraic[8] = 1.2*pow(states[3], 4.0); - algebraic[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); - algebraic[1] = (algebraic[9]+algebraic[8])*(states[0]+100.0); - rates[0] = -(algebraic[2]+algebraic[1]+algebraic[0])/constants[0]; - algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); - algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2]; - algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); - algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0); - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1]; - algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0); - algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); - rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3]; + algebraicVariables[0] = constants[2]*(states[0]-constants[1]); + algebraicVariables[3] = pow(states[2], 3.0)*states[1]*constants[3]; + algebraicVariables[2] = (algebraicVariables[3]+0.14)*(states[0]-constants[4]); + algebraicVariables[8] = 1.2*pow(states[3], 4.0); + algebraicVariables[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); + algebraicVariables[1] = (algebraicVariables[9]+algebraicVariables[8])*(states[0]+100.0); + rates[0] = -(algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0])/constants[0]; + algebraicVariables[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); + algebraicVariables[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); + rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2]; + algebraicVariables[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); + algebraicVariables[6] = 0.17*exp((-states[0]-90.0)/20.0); + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1]; + algebraicVariables[11] = 0.002*exp((-states[0]-90.0)/80.0); + algebraicVariables[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); + rates[3] = algebraicVariables[10]*(1.0-states[3])-algebraicVariables[11]*states[3]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = constants[2]*(states[0]-constants[1]); - algebraic[3] = pow(states[2], 3.0)*states[1]*constants[3]; - algebraic[2] = (algebraic[3]+0.14)*(states[0]-constants[4]); - algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); - algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); - algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0); - algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); - algebraic[8] = 1.2*pow(states[3], 4.0); - algebraic[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); - algebraic[1] = (algebraic[9]+algebraic[8])*(states[0]+100.0); - algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); - algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0); + algebraicVariables[0] = constants[2]*(states[0]-constants[1]); + algebraicVariables[3] = pow(states[2], 3.0)*states[1]*constants[3]; + algebraicVariables[2] = (algebraicVariables[3]+0.14)*(states[0]-constants[4]); + algebraicVariables[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); + algebraicVariables[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); + algebraicVariables[6] = 0.17*exp((-states[0]-90.0)/20.0); + algebraicVariables[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); + algebraicVariables[8] = 1.2*pow(states[3], 4.0); + algebraicVariables[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); + algebraicVariables[1] = (algebraicVariables[9]+algebraicVariables[8])*(states[0]+100.0); + algebraicVariables[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); + algebraicVariables[11] = 0.002*exp((-states[0]-90.0)/80.0); } diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index 91f4bcba0..912f18c9c 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[9]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 7d7234738..a9d7b2fd2 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 4 CONSTANT_COUNT = 5 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 12 +ALGEBRAIC_VARIABLE_COUNT = 12 VOI_INFO = {"name": "time", "units": "millisecond", "component": "environment"} @@ -60,11 +60,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = -87.0 states[1] = 0.8 states[2] = 0.01 @@ -80,35 +80,35 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = constants[2]*(states[0]-constants[1]) - algebraic[3] = pow(states[2], 3.0)*states[1]*constants[3] - algebraic[2] = (algebraic[3]+0.14)*(states[0]-constants[4]) - algebraic[8] = 1.2*pow(states[3], 4.0) - algebraic[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) - algebraic[1] = (algebraic[9]+algebraic[8])*(states[0]+100.0) - rates[0] = -(algebraic[2]+algebraic[1]+algebraic[0])/constants[0] - algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) - algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) - rates[2] = algebraic[4]*(1.0-states[2])-algebraic[5]*states[2] - algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) - algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0) - rates[1] = algebraic[6]*(1.0-states[1])-algebraic[7]*states[1] - algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0) - algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) - rates[3] = algebraic[10]*(1.0-states[3])-algebraic[11]*states[3] - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = constants[2]*(states[0]-constants[1]) - algebraic[3] = pow(states[2], 3.0)*states[1]*constants[3] - algebraic[2] = (algebraic[3]+0.14)*(states[0]-constants[4]) - algebraic[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) - algebraic[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) - algebraic[6] = 0.17*exp((-states[0]-90.0)/20.0) - algebraic[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) - algebraic[8] = 1.2*pow(states[3], 4.0) - algebraic[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) - algebraic[1] = (algebraic[9]+algebraic[8])*(states[0]+100.0) - algebraic[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) - algebraic[11] = 0.002*exp((-states[0]-90.0)/80.0) +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = constants[2]*(states[0]-constants[1]) + algebraicVariables[3] = pow(states[2], 3.0)*states[1]*constants[3] + algebraicVariables[2] = (algebraicVariables[3]+0.14)*(states[0]-constants[4]) + algebraicVariables[8] = 1.2*pow(states[3], 4.0) + algebraicVariables[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) + algebraicVariables[1] = (algebraicVariables[9]+algebraicVariables[8])*(states[0]+100.0) + rates[0] = -(algebraicVariables[2]+algebraicVariables[1]+algebraicVariables[0])/constants[0] + algebraicVariables[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) + algebraicVariables[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) + rates[2] = algebraicVariables[4]*(1.0-states[2])-algebraicVariables[5]*states[2] + algebraicVariables[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) + algebraicVariables[6] = 0.17*exp((-states[0]-90.0)/20.0) + rates[1] = algebraicVariables[6]*(1.0-states[1])-algebraicVariables[7]*states[1] + algebraicVariables[11] = 0.002*exp((-states[0]-90.0)/80.0) + algebraicVariables[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) + rates[3] = algebraicVariables[10]*(1.0-states[3])-algebraicVariables[11]*states[3] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = constants[2]*(states[0]-constants[1]) + algebraicVariables[3] = pow(states[2], 3.0)*states[1]*constants[3] + algebraicVariables[2] = (algebraicVariables[3]+0.14)*(states[0]-constants[4]) + algebraicVariables[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) + algebraicVariables[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) + algebraicVariables[6] = 0.17*exp((-states[0]-90.0)/20.0) + algebraicVariables[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) + algebraicVariables[8] = 1.2*pow(states[3], 4.0) + algebraicVariables[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) + algebraicVariables[1] = (algebraicVariables[9]+algebraicVariables[8])*(states[0]+100.0) + algebraicVariables[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) + algebraicVariables[11] = 0.002*exp((-states[0]-90.0)/80.0) diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index 3b8bdd928..d919490b2 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment"}; @@ -62,11 +62,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; @@ -88,11 +88,11 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = computedConstants[0]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index 9e491081b..41e5207c3 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index fb17e5f4d..0ec4edf87 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "environment"} @@ -41,11 +41,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 @@ -54,9 +54,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = computed_constants[0] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index 163cdbcd7..c2d619c92 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 1; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component"}; @@ -62,11 +62,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; @@ -88,11 +88,11 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = computedConstants[0]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index 0cf4442b7..61940eb44 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 5565726bd..51ebe69f5 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 1 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} @@ -41,11 +41,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 @@ -54,9 +54,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = computed_constants[0] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index 3564b0178..a0a79e7b1 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment"}; @@ -62,11 +62,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; constants[0] = 1.0; @@ -88,11 +88,11 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = constants[0]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index 9e491081b..41e5207c3 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index 5a7099b2a..f6dae349b 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "environment"} @@ -41,11 +41,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 constants[0] = 1.0 @@ -54,9 +54,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = constants[0] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index ce6da46fc..d3191eb73 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component"}; @@ -62,11 +62,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; constants[0] = 1.0; @@ -88,11 +88,11 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = constants[0]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index 0cf4442b7..61940eb44 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 94f9c6134..87b5e723e 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} @@ -41,11 +41,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 constants[0] = 1.0 @@ -54,9 +54,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = constants[0] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index 72ff3f904..be1ec403c 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment"}; @@ -61,11 +61,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; } @@ -86,11 +86,11 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index 9e491081b..41e5207c3 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index d7dfb28f5..69737da89 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "environment"} @@ -40,11 +40,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 @@ -52,9 +52,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 435843298..2ffb9c96d 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component"}; @@ -61,11 +61,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; } @@ -86,11 +86,11 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index 0cf4442b7..61940eb44 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index e9282025e..08c6b083b 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} @@ -40,11 +40,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 @@ -52,9 +52,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 1.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index 595ee1270..dbea529dc 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment"}; @@ -63,11 +63,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = -2.0; @@ -90,12 +90,12 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[1] = states[0]*1.0; rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index 1bcaec686..482289ea6 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[8]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 8887ccf68..596d4e98d 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 2 CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "environment"} @@ -42,11 +42,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = -2.0 constants[0] = 1.0 @@ -56,10 +56,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[1] = states[0]*1.0 rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 947c02d76..350f26c85 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "my_component"}; @@ -63,11 +63,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = -2.0; @@ -90,12 +90,12 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[1] = states[0]*1.0; rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index 2ea06f038..c20a5bbd2 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[8]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 40c2f4bf6..34967078d 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 2 CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "my_component"} @@ -42,11 +42,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = -2.0 constants[0] = 1.0 @@ -56,10 +56,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[1] = states[0]*1.0 rates[0] = (constants[0]*(1.0-pow(states[1], 2.0))*states[0]-states[1])*1.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 5bea76b02..007963343 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment"}; @@ -63,11 +63,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; states[1] = 1.0; @@ -90,12 +90,12 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 1.0; rates[1] = constants[0]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index 670773ddb..798b00b58 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index 9ce90f941..fa585da0d 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 2 CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "environment"} @@ -42,11 +42,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 states[1] = 1.0 constants[0] = 1.0 @@ -56,10 +56,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 1.0 rates[1] = constants[0] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index ba61a382b..152cd7be9 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 0; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "environment"}; @@ -62,11 +62,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; states[1] = 1.0; @@ -88,12 +88,12 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 1.0; rates[1] = states[0]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index 9e491081b..41e5207c3 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[2]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 0e1d5bdf1..92eede813 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 2 CONSTANT_COUNT = 0 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "environment"} @@ -41,11 +41,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 states[1] = 1.0 @@ -54,10 +54,10 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 1.0 rates[1] = states[0] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 86a1b80a0..b504b65ef 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; const size_t CONSTANT_COUNT = 3; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; const VariableInfo VOI_INFO = {"t", "dimensionless", "main"}; @@ -67,11 +67,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -89,7 +89,7 @@ typedef struct { double *rates; double *constants; double *computedConstants; - double *algebraic; + double *algebraicVariables; } RootFindingInfo; extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), @@ -102,48 +102,48 @@ void objectiveFunction0(double *u, double *f, void *data) double *rates = ((RootFindingInfo *) data)->rates; double *constants = ((RootFindingInfo *) data)->constants; double *computedConstants = ((RootFindingInfo *) data)->computedConstants; - double *algebraic = ((RootFindingInfo *) data)->algebraic; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; - f[0] = 1.0-(states[1]+states[0]+algebraic[0]); + f[0] = 1.0-(states[1]+states[0]+algebraicVariables[0]); } -void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraic }; + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; double u[1]; - u[0] = algebraic[0]; + u[0] = algebraicVariables[0]; nlaSolve(objectiveFunction0, u, 1, &rfi); - algebraic[0] = u[0]; + algebraicVariables[0] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 1.0; constants[0] = 1.0e4; constants[1] = 0.04; constants[2] = 3.0e7; - algebraic[0] = 0.0; + algebraicVariables[0] = 0.0; } void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(voi, states, rates, constants, computedConstants, algebraic); - rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraic[0]; - rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraic[0]; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraicVariables[0]; + rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraicVariables[0]; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(voi, states, rates, constants, computedConstants, algebraic); - algebraic[1] = 10000.0*states[0]; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[1] = 10000.0*states[0]; } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index ed7d57014..bb6472c3a 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[10]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index c01e37e56..67cbf9550 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -10,7 +10,7 @@ STATE_COUNT = 2 CONSTANT_COUNT = 3 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 2 VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} @@ -46,8 +46,8 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT from nlasolver import nla_solve @@ -59,42 +59,42 @@ def objective_function_0(u, f, data): rates = data[2] constants = data[3] computed_constants = data[4] - algebraic = data[5] + algebraic_variables = data[5] - algebraic[0] = u[0] + algebraicVariables[0] = u[0] - f[0] = 1.0-(states[1]+states[0]+algebraic[0]) + f[0] = 1.0-(states[1]+states[0]+algebraicVariables[0]) -def find_root_0(voi, states, rates, constants, computed_constants, algebraic): +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): u = [nan]*1 - u[0] = algebraic[0] + u[0] = algebraicVariables[0] - u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic]) + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) - algebraic[0] = u[0] + algebraicVariables[0] = u[0] -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 1.0 constants[0] = 1.0e4 constants[1] = 0.04 constants[2] = 3.0e7 - algebraic[0] = 0.0 + algebraicVariables[0] = 0.0 def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): - find_root_0(voi, states, rates, constants, computed_constants, algebraic) - rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraic[0] - rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraic[0] +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + rates[1] = -constants[1]*states[1]+constants[0]*states[0]*algebraicVariables[0] + rates[0] = constants[1]*states[1]-constants[2]*pow(states[0], 2.0)-constants[0]*states[0]*algebraicVariables[0] -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - find_root_0(voi, states, rates, constants, computed_constants, algebraic) - algebraic[1] = 10000.0*states[0] +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + algebraicVariables[1] = 10000.0*states[0] diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 04ef867e8..df40711df 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 3; const size_t CONSTANT_COUNT = 3; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; const VariableInfo VOI_INFO = {"t", "dimensionless", "main"}; @@ -67,11 +67,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -83,7 +83,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.0; @@ -97,14 +97,14 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[2] = -constants[1]*states[2]+constants[0]*states[1]*states[0]; rates[1] = constants[1]*states[2]-constants[2]*pow(states[1], 2.0)-constants[0]*states[1]*states[0]; rates[0] = constants[2]*pow(states[1], 2.0); } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = 10000.0*states[1]; + algebraicVariables[0] = 10000.0*states[1]; } diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index ed7d57014..bb6472c3a 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[10]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index ddfda730e..3e64e93a3 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -10,7 +10,7 @@ STATE_COUNT = 3 CONSTANT_COUNT = 3 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} @@ -46,11 +46,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.0 states[2] = 1.0 @@ -63,11 +63,11 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[2] = -constants[1]*states[2]+constants[0]*states[1]*states[0] rates[1] = constants[1]*states[2]-constants[2]*pow(states[1], 2.0)-constants[0]*states[1]*states[0] rates[0] = constants[2]*pow(states[1], 2.0) -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = 10000.0*states[1] +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = 10000.0*states[1] diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index 46fb9e568..d1ba5d822 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 2; const size_t COMPUTED_CONSTANT_COUNT = 5; -const size_t ALGEBRAIC_COUNT = 3; +const size_t ALGEBRAIC_VARIABLE_COUNT = 3; const VariableInfo VOI_INFO = {"x", "dimensionless", "main"}; @@ -71,11 +71,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -87,7 +87,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 0.0; states[0] = constants[0]; @@ -103,14 +103,14 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = cos(voi); } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraic[0] = sin(voi); - algebraic[2] = (voi < computedConstants[2])?voi*computedConstants[0]-0.5:(voi < computedConstants[3])?(3.14159265358979-voi)*computedConstants[0]-0.5:(voi < computedConstants[4])?(voi-3.14159265358979)*computedConstants[0]-0.5:(computedConstants[1]-voi)*computedConstants[0]-0.5; - algebraic[1] = (voi < computedConstants[2])?-algebraic[2]*algebraic[2]+constants[1]+algebraic[2]:(voi < computedConstants[3])?-algebraic[2]*algebraic[2]+constants[1]+algebraic[2]:(voi < computedConstants[4])?algebraic[2]*algebraic[2]-constants[1]-algebraic[2]:algebraic[2]*algebraic[2]-constants[1]-algebraic[2]; + algebraicVariables[0] = sin(voi); + algebraicVariables[2] = (voi < computedConstants[2])?voi*computedConstants[0]-0.5:(voi < computedConstants[3])?(3.14159265358979-voi)*computedConstants[0]-0.5:(voi < computedConstants[4])?(voi-3.14159265358979)*computedConstants[0]-0.5:(computedConstants[1]-voi)*computedConstants[0]-0.5; + algebraicVariables[1] = (voi < computedConstants[2])?-algebraicVariables[2]*algebraicVariables[2]+constants[1]+algebraicVariables[2]:(voi < computedConstants[3])?-algebraicVariables[2]*algebraicVariables[2]+constants[1]+algebraicVariables[2]:(voi < computedConstants[4])?algebraicVariables[2]*algebraicVariables[2]-constants[1]-algebraicVariables[2]:algebraicVariables[2]*algebraicVariables[2]-constants[1]-algebraicVariables[2]; } diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index bb8ef07e7..1127d70be 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[27]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index 3e71cba10..a2db9275f 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 2 COMPUTED_CONSTANT_COUNT = 5 -ALGEBRAIC_COUNT = 3 +ALGEBRAIC_VARIABLE_COUNT = 3 VOI_INFO = {"name": "x", "units": "dimensionless", "component": "main"} @@ -54,11 +54,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): constants[0] = 0.0 states[0] = constants[0] constants[1] = 0.75 @@ -73,11 +73,11 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = cos(voi) -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): - algebraic[0] = sin(voi) - algebraic[2] = voi*computed_constants[0]-0.5 if lt_func(voi, computed_constants[2]) else (3.14159265358979-voi)*computed_constants[0]-0.5 if lt_func(voi, computed_constants[3]) else (voi-3.14159265358979)*computed_constants[0]-0.5 if lt_func(voi, computed_constants[4]) else (computed_constants[1]-voi)*computed_constants[0]-0.5 - algebraic[1] = -algebraic[2]*algebraic[2]+constants[1]+algebraic[2] if lt_func(voi, computed_constants[2]) else -algebraic[2]*algebraic[2]+constants[1]+algebraic[2] if lt_func(voi, computed_constants[3]) else algebraic[2]*algebraic[2]-constants[1]-algebraic[2] if lt_func(voi, computed_constants[4]) else algebraic[2]*algebraic[2]-constants[1]-algebraic[2] +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraicVariables[0] = sin(voi) + algebraicVariables[2] = voi*computed_constants[0]-0.5 if lt_func(voi, computed_constants[2]) else (3.14159265358979-voi)*computed_constants[0]-0.5 if lt_func(voi, computed_constants[3]) else (voi-3.14159265358979)*computed_constants[0]-0.5 if lt_func(voi, computed_constants[4]) else (computed_constants[1]-voi)*computed_constants[0]-0.5 + algebraicVariables[1] = -algebraicVariables[2]*algebraicVariables[2]+constants[1]+algebraicVariables[2] if lt_func(voi, computed_constants[2]) else -algebraicVariables[2]*algebraicVariables[2]+constants[1]+algebraicVariables[2] if lt_func(voi, computed_constants[3]) else algebraicVariables[2]*algebraicVariables[2]-constants[1]-algebraicVariables[2] if lt_func(voi, computed_constants[4]) else algebraicVariables[2]*algebraicVariables[2]-constants[1]-algebraicVariables[2] diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index ce2bd9222..48d3ff3e9 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -10,8 +10,8 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 8; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 1; -const size_t EXTERNAL_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; const VariableInfo CONSTANT_INFO[] = { {"P_5", "per_sec3", "SLC_template3_ss"}, @@ -57,22 +57,22 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } return res; } -double * createExternalsArray() +double * createExternalVariablesArray() { - double *res = (double *) malloc(EXTERNAL_COUNT*sizeof(double)); + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < EXTERNAL_COUNT; ++i) { + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -84,7 +84,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 810000.0; constants[1] = 150.0; @@ -100,8 +100,8 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable) +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externals[0] = externalVariable(constants, computedConstants, algebraic, externals, 0); - algebraic[0] = constants[7]*(constants[6]*constants[1]-constants[5]*constants[2])/(constants[4]*constants[2]+externals[0]*constants[1]+constants[3]*constants[2]*constants[1]+constants[0]); + externalVariables[0] = externalVariable(constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = constants[7]*(constants[6]*constants[1]-constants[5]*constants[2])/(constants[4]*constants[2]+externalVariables[0]*constants[1]+constants[3]*constants[2]*constants[1]+constants[0]); } diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index 0fdf636e1..a8409a3ac 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -9,8 +9,8 @@ extern const char LIBCELLML_VERSION[]; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; -extern const size_t EXTERNAL_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; typedef struct { char name[5]; @@ -25,13 +25,13 @@ extern const VariableInfo EXTERNAL_INFO[]; double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); -double * createExternalsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); void deleteArray(double *array); -typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraic, double *externals, size_t index); +typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeVariables(double *constants, double *computedConstants, double *algebraic, double *externals, ExternalVariable externalVariable); +void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 07f234d0d..2899f193a 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -9,8 +9,8 @@ CONSTANT_COUNT = 8 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 1 -EXTERNAL_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 CONSTANT_INFO = [ {"name": "P_5", "units": "per_sec3", "component": "SLC_template3_ss"}, @@ -43,15 +43,15 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def create_externals_array(): - return [nan]*EXTERNAL_COUNT +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic): +def initialise_variables(constants, computed_constants, algebraic_variables): constants[0] = 810000.0 constants[1] = 150.0 constants[2] = 2.0 @@ -66,6 +66,6 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_variables(constants, computed_constants, algebraic, externals, external_variable): - externals[0] = external_variable(constants, computed_constants, algebraic, externals, 0) - algebraic[0] = constants[7]*(constants[6]*constants[1]-constants[5]*constants[2])/(constants[4]*constants[2]+externals[0]*constants[1]+constants[3]*constants[2]*constants[1]+constants[0]) +def compute_variables(constants, computed_constants, algebraic_variables, external_variables, external_variable): + externalVariables[0] = external_variable(constants, computed_constants, algebraic_variables, external_variables, 0) + algebraicVariables[0] = constants[7]*(constants[6]*constants[1]-constants[5]*constants[2])/(constants[4]*constants[2]+externalVariables[0]*constants[1]+constants[3]*constants[2]*constants[1]+constants[0]) diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 4f08cb86e..2abddb7f3 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -11,7 +11,7 @@ const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; const size_t CONSTANT_COUNT = 1; const size_t COMPUTED_CONSTANT_COUNT = 0; -const size_t ALGEBRAIC_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; const VariableInfo VOI_INFO = {"t", "second", "component_1"}; @@ -62,11 +62,11 @@ double * createComputedConstantsArray() return res; } -double * createAlgebraicArray() +double * createAlgebraicVariablesArray() { - double *res = (double *) malloc(ALGEBRAIC_COUNT*sizeof(double)); + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - for (size_t i = 0; i < ALGEBRAIC_COUNT; ++i) { + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { res[i] = NAN; } @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 7.0; states[0] = constants[0]; @@ -88,11 +88,11 @@ void computeComputedConstants(double *constants, double *computedConstants) { } -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { rates[0] = 3.0; } -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index 72ba8c278..51591d2bf 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -10,7 +10,7 @@ extern const char LIBCELLML_VERSION[]; extern const size_t STATE_COUNT; extern const size_t CONSTANT_COUNT; extern const size_t COMPUTED_CONSTANT_COUNT; -extern const size_t ALGEBRAIC_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { char name[7]; @@ -27,11 +27,11 @@ extern const VariableInfo ALGEBRAIC_INFO[]; double * createStatesArray(); double * createConstantsArray(); double * createComputedConstantsArray(); -double * createAlgebraicArray(); +double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); -void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); -void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraic); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index fb828996a..10f33fd7b 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -10,7 +10,7 @@ STATE_COUNT = 1 CONSTANT_COUNT = 1 COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 VOI_INFO = {"name": "t", "units": "second", "component": "component_1"} @@ -41,11 +41,11 @@ def create_computed_constants_array(): return [nan]*COMPUTED_CONSTANT_COUNT -def create_algebraic_array(): - return [nan]*ALGEBRAIC_COUNT +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic): +def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): constants[0] = 7.0 states[0] = constants[0] @@ -54,9 +54,9 @@ def compute_computed_constants(constants, computed_constants): pass -def compute_rates(voi, states, rates, constants, computed_constants, algebraic): +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): rates[0] = 3.0 -def compute_variables(voi, states, rates, constants, computed_constants, algebraic): +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): pass From 01ab5935d98289f361e67b75b1495711c095f3e8 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 4 Nov 2025 16:50:58 +1300 Subject: [PATCH 63/74] Generator: improved the implementation of Generator::GeneratorImpl::analyserVariable(). --- src/generator.cpp | 24 +++--------------------- 1 file changed, 3 insertions(+), 21 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index ac5eb9c88..ac1e0edef 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -76,29 +76,11 @@ AnalyserVariablePtr Generator::GeneratorImpl::analyserVariable(const VariablePtr && mModel->areEquivalentVariables(variable, modelVoiVariable)) { res = modelVoi; } else { - // Normally, we would have something like: - // - // for (const auto &modelVariable : variables(mModel)) { - // if (mModel->areEquivalentVariables(variable, modelVariable->variable())) { - // res = modelVariable; - // - // break; - // } - // } - // - // but we always have variables, so llvm-cov will complain that the false branch of our for loop is never - // reached. The below code is a bit more verbose but at least it makes llvm-cov happy. - auto modelVariables = variables(mModel); - auto modelVariable = modelVariables.begin(); - do { - if (mModel->areEquivalentVariables(variable, (*modelVariable)->variable())) { - res = *modelVariable; - } else { - ++modelVariable; - } - } while (res == nullptr); + res = *std::find_if(modelVariables.begin(), modelVariables.end(), [=](const auto &modelVariable) { + return mModel->areEquivalentVariables(modelVariable->variable(), variable); + }); } return res; From 94c54689f8124e0185f446c20d8d8e8cd7251c21 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 4 Nov 2025 16:53:49 +1300 Subject: [PATCH 64/74] Generator: use temporary variable. --- src/generator.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index ac1e0edef..033c5f4cc 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -95,10 +95,11 @@ double Generator::GeneratorImpl::scalingFactor(const VariablePtr &variable) cons if ((analyserVariable->type() == AnalyserVariable::Type::CONSTANT) && !isCellMLReal(variable->initialValue())) { - auto initialValueVariable = owningComponent(variable)->variable(variable->initialValue()); + auto variableComponent = owningComponent(variable); + auto initialValueVariable = variableComponent->variable(variable->initialValue()); auto initialValueAnalyserVariable = Generator::GeneratorImpl::analyserVariable(initialValueVariable); - if (owningComponent(variable) != owningComponent(initialValueAnalyserVariable->variable())) { + if (variableComponent != owningComponent(initialValueAnalyserVariable->variable())) { return Units::scalingFactor(initialValueVariable->units(), variable->units()); } } From 0114a6137da04c14de8a0df0bc7d6feeb19be396 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 4 Nov 2025 16:56:55 +1300 Subject: [PATCH 65/74] Generator: use a more suitable parameter name in Generator::GeneratorImpl::doAddImplementationVariableInfoCode(). --- src/generator.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index 033c5f4cc..09cb1b118 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -434,7 +434,7 @@ void Generator::GeneratorImpl::addInterfaceVariableInfoCode() } void Generator::GeneratorImpl::doAddImplementationVariableInfoCode(const std::string &variableInfoString, - const std::vector &variables, + const std::vector &analyserVariables, bool voiVariable) { if (!variableInfoString.empty() @@ -442,12 +442,12 @@ void Generator::GeneratorImpl::doAddImplementationVariableInfoCode(const std::st && !mProfile->arrayElementSeparatorString().empty()) { std::string infoElementsCode; - for (const auto &variable : variables) { + for (const auto &analyserVariable : analyserVariables) { if (!infoElementsCode.empty()) { infoElementsCode += mProfile->arrayElementSeparatorString() + "\n"; } - auto variableVariable = variable->variable(); + auto variableVariable = analyserVariable->variable(); infoElementsCode += (voiVariable ? "" : mProfile->indentString()) + generateVariableInfoEntryCode(variableVariable->name(), From 7b73df6a0a5fe3b0bab293433d7a469a22e6a8a5 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 4 Nov 2025 17:16:25 +1300 Subject: [PATCH 66/74] Generator: simplified the implementation of Generator::GeneratorImpl::addImplementationVariableInfoCode(). --- src/generator.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index 09cb1b118..6e468f8bc 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -468,9 +468,6 @@ void Generator::GeneratorImpl::addImplementationVariableInfoCode() { if (modelHasOdes()) { doAddImplementationVariableInfoCode(mProfile->implementationVoiInfoString(), {mModel->voi()}, true); - } - - if (modelHasOdes()) { doAddImplementationVariableInfoCode(mProfile->implementationStateInfoString(), mModel->states(), false); } From c8ffaf27c4e5c29dc35133f5ffdc71800dd00b71 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 4 Nov 2025 17:21:44 +1300 Subject: [PATCH 67/74] Generator: slight improvement to Generator::GeneratorImpl::generateEquationCode(). --- src/generator.cpp | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index 6e468f8bc..d17050cf1 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1731,14 +1731,15 @@ std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquatio } break; - case AnalyserEquation::Type::NLA: - if (!mProfile->findRootCallString(modelHasOdes(), mModel->hasExternalVariables()).empty()) { + case AnalyserEquation::Type::NLA: { + auto modelHasOdes = this->modelHasOdes(); + + if (!mProfile->findRootCallString(modelHasOdes, mModel->hasExternalVariables()).empty()) { res += mProfile->indentString() - + replace(mProfile->findRootCallString(modelHasOdes(), mModel->hasExternalVariables()), + + replace(mProfile->findRootCallString(modelHasOdes, mModel->hasExternalVariables()), "[INDEX]", convertToString(equation->nlaSystemIndex())); } - - break; + } break; default: res += mProfile->indentString() + generateCode(equation->ast()) + mProfile->commandSeparatorString() + "\n"; From 8c5ef05a86f04b64e80a92bef69ec29a8140db4b Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 4 Nov 2025 17:28:30 +1300 Subject: [PATCH 68/74] Generator: use C++ overloading functionality. --- src/generator.cpp | 18 +++++++++--------- src/generator_p.h | 4 ++-- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index d17050cf1..35ad53da0 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -433,9 +433,9 @@ void Generator::GeneratorImpl::addInterfaceVariableInfoCode() } } -void Generator::GeneratorImpl::doAddImplementationVariableInfoCode(const std::string &variableInfoString, - const std::vector &analyserVariables, - bool voiVariable) +void Generator::GeneratorImpl::addImplementationVariableInfoCode(const std::string &variableInfoString, + const std::vector &analyserVariables, + bool voiVariable) { if (!variableInfoString.empty() && !mProfile->variableInfoEntryString().empty() @@ -467,16 +467,16 @@ void Generator::GeneratorImpl::doAddImplementationVariableInfoCode(const std::st void Generator::GeneratorImpl::addImplementationVariableInfoCode() { if (modelHasOdes()) { - doAddImplementationVariableInfoCode(mProfile->implementationVoiInfoString(), {mModel->voi()}, true); - doAddImplementationVariableInfoCode(mProfile->implementationStateInfoString(), mModel->states(), false); + addImplementationVariableInfoCode(mProfile->implementationVoiInfoString(), {mModel->voi()}, true); + addImplementationVariableInfoCode(mProfile->implementationStateInfoString(), mModel->states(), false); } - doAddImplementationVariableInfoCode(mProfile->implementationConstantInfoString(), mModel->constants(), false); - doAddImplementationVariableInfoCode(mProfile->implementationComputedConstantInfoString(), mModel->computedConstants(), false); - doAddImplementationVariableInfoCode(mProfile->implementationAlgebraicVariableInfoString(), mModel->algebraicVariables(), false); + addImplementationVariableInfoCode(mProfile->implementationConstantInfoString(), mModel->constants(), false); + addImplementationVariableInfoCode(mProfile->implementationComputedConstantInfoString(), mModel->computedConstants(), false); + addImplementationVariableInfoCode(mProfile->implementationAlgebraicVariableInfoString(), mModel->algebraicVariables(), false); if (mModel->hasExternalVariables()) { - doAddImplementationVariableInfoCode(mProfile->implementationExternalVariableInfoString(), mModel->externalVariables(), false); + addImplementationVariableInfoCode(mProfile->implementationExternalVariableInfoString(), mModel->externalVariables(), false); } } diff --git a/src/generator_p.h b/src/generator_p.h index d85e8e2f4..e98319c24 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -90,8 +90,8 @@ struct Generator::GeneratorImpl void addInterfaceVariableInfoCode(); - void doAddImplementationVariableInfoCode(const std::string &variableInfoString, - const std::vector &variables, bool voiVariable); + void addImplementationVariableInfoCode(const std::string &variableInfoString, + const std::vector &variables, bool voiVariable); void addImplementationVariableInfoCode(); void addArithmeticFunctionsCode(); From bbc20a9d8e11fd3d16730e3ec7f9667b52b5189a Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 4 Nov 2025 17:34:05 +1300 Subject: [PATCH 69/74] Utilities: renamed our `variables()` utility to `analyserVariables()`. --- src/analyserequation.cpp | 2 +- src/debug.cpp | 2 +- src/generator.cpp | 18 +++++++++--------- src/utilities.cpp | 4 ++-- src/utilities.h | 20 ++++++++++---------- 5 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/analyserequation.cpp b/src/analyserequation.cpp index fff98bb0f..939f24fe5 100644 --- a/src/analyserequation.cpp +++ b/src/analyserequation.cpp @@ -31,7 +31,7 @@ AnalyserEquationPtr AnalyserEquation::AnalyserEquationImpl::create() bool AnalyserEquation::AnalyserEquationImpl::isEmptyDependency(const AnalyserEquationWeakPtr &dependency) { - auto variables = libcellml::variables(dependency.lock()); + auto variables = libcellml::analyserVariables(dependency.lock()); if (std::any_of(variables.begin(), variables.end(), [](const auto &v) { return v != nullptr; })) { return false; diff --git a/src/debug.cpp b/src/debug.cpp index e431719af..ed679eecd 100644 --- a/src/debug.cpp +++ b/src/debug.cpp @@ -168,7 +168,7 @@ void printAnalyserModelVariables(const AnalyserModelPtr &model) { size_t varNb = 0; - for (const auto &var : variables(model)) { + for (const auto &var : analyserVariables(model)) { Debug() << "\n---------------------------------------[API variable #" << ++varNb << "]"; Debug() << "\nName: " << var->variable()->name(); Debug() << "Type: " << AnalyserVariable::typeAsString(var->type()); diff --git a/src/generator.cpp b/src/generator.cpp index 35ad53da0..e86846bc8 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -76,10 +76,10 @@ AnalyserVariablePtr Generator::GeneratorImpl::analyserVariable(const VariablePtr && mModel->areEquivalentVariables(variable, modelVoiVariable)) { res = modelVoi; } else { - auto modelVariables = variables(mModel); + auto modelAnalyserVariables = analyserVariables(mModel); - res = *std::find_if(modelVariables.begin(), modelVariables.end(), [=](const auto &modelVariable) { - return mModel->areEquivalentVariables(modelVariable->variable(), variable); + res = *std::find_if(modelAnalyserVariables.begin(), modelAnalyserVariables.end(), [=](const auto &modelAnalyserVariable) { + return mModel->areEquivalentVariables(modelAnalyserVariable->variable(), variable); }); } @@ -368,7 +368,7 @@ std::string Generator::GeneratorImpl::generateVariableInfoObjectCode(const std:: size_t nameSize = 0; size_t unitsSize = 0; - for (const auto &variable : variables(mModel)) { + for (const auto &variable : analyserVariables(mModel)) { updateVariableInfoSizes(componentSize, nameSize, unitsSize, variable); } @@ -748,7 +748,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() && (std::find(handledNlaEquations.begin(), handledNlaEquations.end(), equation) == handledNlaEquations.end())) { std::string methodBody; auto i = MAX_SIZE_T; - auto variables = libcellml::variables(equation); + auto variables = libcellml::analyserVariables(equation); for (const auto &variable : variables) { auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? @@ -1721,12 +1721,12 @@ std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquatio switch (equation->type()) { case AnalyserEquation::Type::EXTERNAL: - for (const auto &variable : variables(equation)) { + for (const auto &analyserVariable : analyserVariables(equation)) { res += mProfile->indentString() - + generateVariableNameCode(variable->variable()) + + generateVariableNameCode(analyserVariable->variable()) + mProfile->equalityString() + replace(mProfile->externalVariableMethodCallString(modelHasOdes()), - "[INDEX]", convertToString(variable->index())) + "[INDEX]", convertToString(analyserVariable->index())) + mProfile->commandSeparatorString() + "\n"; } @@ -1922,7 +1922,7 @@ void Generator::GeneratorImpl::addImplementationComputeRatesMethodCode(std::vect // NLA equation in case the rate is not on its own on either the LHS // or RHS of the equation. - auto variables = libcellml::variables(equation); + auto variables = libcellml::analyserVariables(equation); if ((equation->type() == AnalyserEquation::Type::ODE) || ((equation->type() == AnalyserEquation::Type::NLA) diff --git a/src/utilities.cpp b/src/utilities.cpp index a7eaf0430..91ee9abeb 100644 --- a/src/utilities.cpp +++ b/src/utilities.cpp @@ -1317,7 +1317,7 @@ XmlNodePtr mathmlChildNode(const XmlNodePtr &node, size_t index) return res; } -std::vector variables(const AnalyserModelPtr &model) +std::vector analyserVariables(const AnalyserModelPtr &model) { std::vector res; @@ -1340,7 +1340,7 @@ std::vector variables(const AnalyserModelPtr &model) return res; } -std::vector variables(const AnalyserEquationPtr &equation) +std::vector analyserVariables(const AnalyserEquationPtr &equation) { auto res = equation->states(); auto computedConstants = equation->computedConstants(); diff --git a/src/utilities.h b/src/utilities.h index 87beda8af..417f5bd79 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -871,25 +871,25 @@ size_t mathmlChildCount(const XmlNodePtr &node); XmlNodePtr mathmlChildNode(const XmlNodePtr &node, size_t index); /** - * @brief Return the variables in the given model. + * @brief Return the analyser variables in the given model. * - * Return the variables in the given model. + * Return the analyser variables in the given model. * - * @param model The model for which we want the variables. + * @param model The model for which we want the analyser variables. * - * @return The variables in the given model. + * @return The analyser variables in the given model. */ -std::vector variables(const AnalyserModelPtr &model); +std::vector analyserVariables(const AnalyserModelPtr &model); /** - * @brief Return the variables in the given equation. + * @brief Return the analyser variables in the given equation. * - * Return the variables in the given equation. + * Return the analyser variables in the given equation. * - * @param equation The equation for which we want the variables. + * @param equation The equation for which we want the analyser variables. * - * @return The variables in the given equation. + * @return The analyser variables in the given equation. */ -std::vector variables(const AnalyserEquationPtr &equation); +std::vector analyserVariables(const AnalyserEquationPtr &equation); } // namespace libcellml From e46d26745822be0e35d3a2ec3d4e0bf9c128c18e Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 4 Nov 2025 18:35:03 +1300 Subject: [PATCH 70/74] Generator: use `analyserVariable` rather than `variable` to distinguish between our two types of variables. --- src/generator.cpp | 28 ++++++++++++++-------------- src/generator_p.h | 8 ++++---- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index e86846bc8..aec8b30cf 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -208,12 +208,12 @@ bool Generator::GeneratorImpl::isPiecewiseStatement(const AnalyserEquationAstPtr void Generator::GeneratorImpl::updateVariableInfoSizes(size_t &componentSize, size_t &nameSize, size_t &unitsSize, - const AnalyserVariablePtr &variable) const + const AnalyserVariablePtr &analyserVariable) const { - auto variableVariable = variable->variable(); - auto variableComponentSize = owningComponent(variableVariable)->name().length() + 1; - auto variableNameSize = variableVariable->name().length() + 1; - auto variableUnitsSize = variableVariable->units()->name().length() + 1; + auto analyserVariableVariable = analyserVariable->variable(); + auto variableComponentSize = owningComponent(analyserVariableVariable)->name().length() + 1; + auto variableNameSize = analyserVariableVariable->name().length() + 1; + auto variableUnitsSize = analyserVariableVariable->units()->name().length() + 1; // Note: +1 to account for the end of string termination. componentSize = (componentSize > variableComponentSize) ? componentSize : variableComponentSize; @@ -447,12 +447,12 @@ void Generator::GeneratorImpl::addImplementationVariableInfoCode(const std::stri infoElementsCode += mProfile->arrayElementSeparatorString() + "\n"; } - auto variableVariable = analyserVariable->variable(); + auto analyserVariableVariable = analyserVariable->variable(); infoElementsCode += (voiVariable ? "" : mProfile->indentString()) - + generateVariableInfoEntryCode(variableVariable->name(), - variableVariable->units()->name(), - owningComponent(variableVariable)->name()); + + generateVariableInfoEntryCode(analyserVariableVariable->name(), + analyserVariableVariable->units()->name(), + owningComponent(analyserVariableVariable)->name()); } if (!voiVariable && !infoElementsCode.empty()) { @@ -1658,18 +1658,18 @@ bool Generator::GeneratorImpl::isSomeConstant(const AnalyserEquationPtr &equatio || (!includeComputedConstants && (type == AnalyserEquation::Type::VARIABLE_BASED_CONSTANT)); } -std::string Generator::GeneratorImpl::generateZeroInitialisationCode(const AnalyserVariablePtr &variable) const +std::string Generator::GeneratorImpl::generateZeroInitialisationCode(const AnalyserVariablePtr &analyserVariable) const { return mProfile->indentString() - + generateVariableNameCode(variable->variable(), false) + + generateVariableNameCode(analyserVariable->variable(), false) + mProfile->equalityString() + "0.0" + mProfile->commandSeparatorString() + "\n"; } -std::string Generator::GeneratorImpl::generateInitialisationCode(const AnalyserVariablePtr &variable) const +std::string Generator::GeneratorImpl::generateInitialisationCode(const AnalyserVariablePtr &analyserVariable) const { - auto initialisingVariable = variable->initialisingVariable(); + auto initialisingVariable = analyserVariable->initialisingVariable(); auto scalingFactor = Generator::GeneratorImpl::scalingFactor(initialisingVariable); std::string scalingFactorCode; @@ -1678,7 +1678,7 @@ std::string Generator::GeneratorImpl::generateInitialisationCode(const AnalyserV } return mProfile->indentString() - + generateVariableNameCode(variable->variable()) + + generateVariableNameCode(analyserVariable->variable()) + mProfile->equalityString() + scalingFactorCode + generateDoubleOrConstantVariableNameCode(initialisingVariable) + mProfile->commandSeparatorString() + "\n"; diff --git a/src/generator_p.h b/src/generator_p.h index e98319c24..16f603b5e 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -65,7 +65,7 @@ struct Generator::GeneratorImpl void updateVariableInfoSizes(size_t &componentSize, size_t &nameSize, size_t &unitsSize, - const AnalyserVariablePtr &variable) const; + const AnalyserVariablePtr &analyserVariable) const; bool modifiedProfile() const; @@ -91,7 +91,7 @@ struct Generator::GeneratorImpl void addInterfaceVariableInfoCode(); void addImplementationVariableInfoCode(const std::string &variableInfoString, - const std::vector &variables, bool voiVariable); + const std::vector &analyserVariables, bool voiVariable); void addImplementationVariableInfoCode(); void addArithmeticFunctionsCode(); @@ -128,8 +128,8 @@ struct Generator::GeneratorImpl bool isSomeConstant(const AnalyserEquationPtr &equation, bool includeComputedConstants) const; - std::string generateZeroInitialisationCode(const AnalyserVariablePtr &variable) const; - std::string generateInitialisationCode(const AnalyserVariablePtr &variable) const; + std::string generateZeroInitialisationCode(const AnalyserVariablePtr &analyserVariable) const; + std::string generateInitialisationCode(const AnalyserVariablePtr &analyserVariable) const; std::string generateEquationCode(const AnalyserEquationPtr &equation, std::vector &remainingEquations, std::vector &equationsForDependencies, From b4045c6cd6ed828f981074b116fd0edc9f9ad210 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 4 Nov 2025 23:18:38 +1300 Subject: [PATCH 71/74] Generator: replaced `initialiseVariables()` with `initialiseArrays()`. This is more consistent with our `createXxxArray()` methods and `deleteArray()` method. --- src/api/libcellml/generatorprofile.h | 16 ++--- src/bindings/interface/generatorprofile.i | 8 +-- src/bindings/javascript/generatorprofile.cpp | 8 +-- src/generator.cpp | 18 ++--- src/generator_p.h | 2 +- src/generatorprofile.cpp | 66 +++++++++---------- src/generatorprofile_p.h | 8 +-- src/generatorprofilesha1values.h | 4 +- src/generatorprofiletools.cpp | 8 +-- .../javascript/generatorprofile.test.js | 20 +++--- .../bindings/python/test_generator_profile.py | 32 ++++----- tests/coverage/coverage.cpp | 4 +- tests/generator/generatorprofile.cpp | 32 ++++----- tests/resources/coverage/generator/model.c | 2 +- tests/resources/coverage/generator/model.h | 2 +- .../generator/model.implementation.out | 2 +- .../coverage/generator/model.interface.out | 2 +- .../generator/model.modified.profile.c | 2 +- .../generator/model.modified.profile.h | 2 +- .../generator/model.modified.profile.py | 2 +- tests/resources/coverage/generator/model.py | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../algebraic_eqn_computed_var_on_rhs/model.h | 2 +- .../model.py | 2 +- .../algebraic_eqn_const_var_on_rhs/model.c | 2 +- .../algebraic_eqn_const_var_on_rhs/model.h | 2 +- .../algebraic_eqn_const_var_on_rhs/model.py | 2 +- .../algebraic_eqn_constant_on_rhs/model.c | 2 +- .../algebraic_eqn_constant_on_rhs/model.h | 2 +- .../algebraic_eqn_constant_on_rhs/model.py | 2 +- .../algebraic_eqn_derivative_on_rhs/model.c | 2 +- .../algebraic_eqn_derivative_on_rhs/model.h | 2 +- .../algebraic_eqn_derivative_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../algebraic_eqn_state_var_on_rhs/model.c | 2 +- .../algebraic_eqn_state_var_on_rhs/model.h | 2 +- .../algebraic_eqn_state_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.not.ordered.c | 2 +- .../model.not.ordered.h | 2 +- .../model.not.ordered.py | 2 +- .../model.ordered.c | 2 +- .../model.ordered.h | 2 +- .../model.ordered.py | 2 +- .../algebraic_unknown_var_on_rhs/model.c | 2 +- .../algebraic_unknown_var_on_rhs/model.h | 2 +- .../algebraic_unknown_var_on_rhs/model.py | 2 +- .../generator/cell_geometry_model/model.c | 2 +- .../cell_geometry_model/model.external.c | 2 +- .../cell_geometry_model/model.external.h | 2 +- .../cell_geometry_model/model.external.py | 2 +- .../generator/cell_geometry_model/model.h | 2 +- .../generator/cell_geometry_model/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/cellml_slc_example/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../cellml_unit_scaling_constant/model.c | 2 +- .../cellml_unit_scaling_constant/model.h | 2 +- .../cellml_unit_scaling_constant/model.py | 2 +- .../cellml_unit_scaling_rate/model.c | 2 +- .../cellml_unit_scaling_rate/model.h | 2 +- .../cellml_unit_scaling_rate/model.py | 2 +- .../cellml_unit_scaling_state/model.c | 2 +- .../cellml_unit_scaling_state/model.h | 2 +- .../cellml_unit_scaling_state/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../cellml_unit_scaling_voi_direct/model.c | 2 +- .../cellml_unit_scaling_voi_direct/model.h | 2 +- .../cellml_unit_scaling_voi_direct/model.py | 2 +- .../cellml_unit_scaling_voi_indirect/model.c | 2 +- .../cellml_unit_scaling_voi_indirect/model.h | 2 +- .../cellml_unit_scaling_voi_indirect/model.py | 2 +- .../generator/dae_cellml_1_1_model/model.c | 2 +- .../generator/dae_cellml_1_1_model/model.h | 2 +- .../generator/dae_cellml_1_1_model/model.py | 2 +- .../generator/dependent_eqns/model.c | 2 +- .../generator/dependent_eqns/model.h | 2 +- .../generator/dependent_eqns/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.algebraic.c | 2 +- .../model.algebraic.h | 2 +- .../model.algebraic.py | 2 +- .../model.c | 2 +- .../model.computed.constant.c | 2 +- .../model.computed.constant.h | 2 +- .../model.computed.constant.py | 2 +- .../model.constant.c | 2 +- .../model.constant.h | 2 +- .../model.constant.py | 2 +- .../model.dae.c | 2 +- .../model.dae.external.c | 2 +- .../model.dae.external.h | 2 +- .../model.dae.external.py | 2 +- .../model.dae.h | 2 +- .../model.dae.py | 2 +- .../model.dependent.algebraic.c | 2 +- .../model.dependent.algebraic.h | 2 +- .../model.dependent.algebraic.py | 2 +- .../model.dependent.computed.constant.c | 2 +- .../model.dependent.computed.constant.h | 2 +- .../model.dependent.computed.constant.py | 2 +- .../model.dependent.constant.c | 2 +- .../model.dependent.constant.h | 2 +- .../model.dependent.constant.py | 2 +- .../model.dependent.state.c | 2 +- .../model.dependent.state.h | 2 +- .../model.dependent.state.py | 2 +- .../model.external.c | 2 +- .../model.external.h | 2 +- .../model.external.py | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.state.c | 2 +- .../model.state.h | 2 +- .../model.state.py | 2 +- .../generator/noble_model_1962/model.c | 2 +- .../generator/noble_model_1962/model.h | 2 +- .../generator/noble_model_1962/model.py | 2 +- .../generator/ode_computed_var_on_rhs/model.c | 2 +- .../generator/ode_computed_var_on_rhs/model.h | 2 +- .../ode_computed_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/ode_const_var_on_rhs/model.c | 2 +- .../generator/ode_const_var_on_rhs/model.h | 2 +- .../generator/ode_const_var_on_rhs/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../generator/ode_constant_on_rhs/model.c | 2 +- .../generator/ode_constant_on_rhs/model.h | 2 +- .../generator/ode_constant_on_rhs/model.py | 2 +- .../ode_constant_on_rhs_one_component/model.c | 2 +- .../ode_constant_on_rhs_one_component/model.h | 2 +- .../model.py | 2 +- .../ode_multiple_dependent_odes/model.c | 2 +- .../ode_multiple_dependent_odes/model.h | 2 +- .../ode_multiple_dependent_odes/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../ode_multiple_odes_with_same_name/model.c | 2 +- .../ode_multiple_odes_with_same_name/model.h | 2 +- .../ode_multiple_odes_with_same_name/model.py | 2 +- .../generator/ode_unknown_var_on_rhs/model.c | 2 +- .../generator/ode_unknown_var_on_rhs/model.h | 2 +- .../generator/ode_unknown_var_on_rhs/model.py | 2 +- .../robertson_model_1966/model.dae.c | 2 +- .../robertson_model_1966/model.dae.h | 2 +- .../robertson_model_1966/model.dae.py | 2 +- .../robertson_model_1966/model.ode.c | 2 +- .../robertson_model_1966/model.ode.h | 2 +- .../robertson_model_1966/model.ode.py | 2 +- .../generator/sine_model_imports/model.c | 2 +- .../generator/sine_model_imports/model.h | 2 +- .../generator/sine_model_imports/model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- .../model.c | 2 +- .../model.h | 2 +- .../model.py | 2 +- 196 files changed, 296 insertions(+), 296 deletions(-) diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index 13bbc64b4..791aa9c64 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -3719,7 +3719,7 @@ class LIBCELLML_EXPORT GeneratorProfile * * @return The @c std::string for the interface to initialise variables. */ - std::string interfaceInitialiseVariablesMethodString(bool forDifferentialModel) const; + std::string interfaceInitialiseArraysMethodString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the interface to initialise variables. @@ -3728,11 +3728,11 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the interface to initialise variables * is for a differential model, as opposed to an algebraic model. - * @param interfaceInitialiseVariablesMethodString The @c std::string to use + * @param interfaceInitialiseArraysMethodString The @c std::string to use * for the interface to initialise variables. */ - void setInterfaceInitialiseVariablesMethodString(bool forDifferentialModel, - const std::string &interfaceInitialiseVariablesMethodString); + void setInterfaceInitialiseArraysMethodString(bool forDifferentialModel, + const std::string &interfaceInitialiseArraysMethodString); /** * @brief Get the @c std::string for the implementation to initialise @@ -3746,7 +3746,7 @@ class LIBCELLML_EXPORT GeneratorProfile * @return The @c std::string for the implementation to initialise * variables. */ - std::string implementationInitialiseVariablesMethodString(bool forDifferentialModel) const; + std::string implementationInitialiseArraysMethodString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the implementation to initialise @@ -3758,11 +3758,11 @@ class LIBCELLML_EXPORT GeneratorProfile * * @param forDifferentialModel Whether the implementation to initialise * variables is for a differential model, as opposed to an algebraic model. - * @param implementationInitialiseVariablesMethodString The @c std::string + * @param implementationInitialiseArraysMethodString The @c std::string * to use for the implementation to initialise variables. */ - void setImplementationInitialiseVariablesMethodString(bool forDifferentialModel, - const std::string &implementationInitialiseVariablesMethodString); + void setImplementationInitialiseArraysMethodString(bool forDifferentialModel, + const std::string &implementationInitialiseArraysMethodString); /** * @brief Get the @c std::string for the interface to compute computed diff --git a/src/bindings/interface/generatorprofile.i b/src/bindings/interface/generatorprofile.i index 791447c2e..3a30837ee 100644 --- a/src/bindings/interface/generatorprofile.i +++ b/src/bindings/interface/generatorprofile.i @@ -1012,16 +1012,16 @@ tag, which will be replaced with some code to create the external variables arra %feature("docstring") libcellml::GeneratorProfile::setImplementationDeleteArrayMethodString "Sets the string for the implementation to delete an array."; -%feature("docstring") libcellml::GeneratorProfile::interfaceInitialiseVariablesMethodString +%feature("docstring") libcellml::GeneratorProfile::interfaceInitialiseArraysMethodString "Returns the string for the interface to initialise variables."; -%feature("docstring") libcellml::GeneratorProfile::setInterfaceInitialiseVariablesMethodString +%feature("docstring") libcellml::GeneratorProfile::setInterfaceInitialiseArraysMethodString "Sets the string for the interface to initialise variables."; -%feature("docstring") libcellml::GeneratorProfile::implementationInitialiseVariablesMethodString +%feature("docstring") libcellml::GeneratorProfile::implementationInitialiseArraysMethodString "Returns the string for the implementation to initialise variables."; -%feature("docstring") libcellml::GeneratorProfile::setImplementationInitialiseVariablesMethodString +%feature("docstring") libcellml::GeneratorProfile::setImplementationInitialiseArraysMethodString "Sets the string for the implementation to initialise variables."; %feature("docstring") libcellml::GeneratorProfile::interfaceComputeComputedConstantsMethodString diff --git a/src/bindings/javascript/generatorprofile.cpp b/src/bindings/javascript/generatorprofile.cpp index 5a006d252..edb50ad26 100644 --- a/src/bindings/javascript/generatorprofile.cpp +++ b/src/bindings/javascript/generatorprofile.cpp @@ -353,10 +353,10 @@ EMSCRIPTEN_BINDINGS(libcellml_generatorprofile) .function("setInterfaceDeleteArrayMethodString", &libcellml::GeneratorProfile::setInterfaceDeleteArrayMethodString) .function("implementationDeleteArrayMethodString", &libcellml::GeneratorProfile::implementationDeleteArrayMethodString) .function("setImplementationDeleteArrayMethodString", &libcellml::GeneratorProfile::setImplementationDeleteArrayMethodString) - .function("interfaceInitialiseVariablesMethodString", &libcellml::GeneratorProfile::interfaceInitialiseVariablesMethodString) - .function("setInterfaceInitialiseVariablesMethodString", &libcellml::GeneratorProfile::setInterfaceInitialiseVariablesMethodString) - .function("implementationInitialiseVariablesMethodString", &libcellml::GeneratorProfile::implementationInitialiseVariablesMethodString) - .function("setImplementationInitialiseVariablesMethodString", &libcellml::GeneratorProfile::setImplementationInitialiseVariablesMethodString) + .function("interfaceInitialiseArraysMethodString", &libcellml::GeneratorProfile::interfaceInitialiseArraysMethodString) + .function("setInterfaceInitialiseArraysMethodString", &libcellml::GeneratorProfile::setInterfaceInitialiseArraysMethodString) + .function("implementationInitialiseArraysMethodString", &libcellml::GeneratorProfile::implementationInitialiseArraysMethodString) + .function("setImplementationInitialiseArraysMethodString", &libcellml::GeneratorProfile::setImplementationInitialiseArraysMethodString) .function("interfaceComputeComputedConstantsMethodString", &libcellml::GeneratorProfile::interfaceComputeComputedConstantsMethodString) .function("setInterfaceComputeComputedConstantsMethodString", &libcellml::GeneratorProfile::setInterfaceComputeComputedConstantsMethodString) .function("implementationComputeComputedConstantsMethodString", &libcellml::GeneratorProfile::implementationComputeComputedConstantsMethodString) diff --git a/src/generator.cpp b/src/generator.cpp index aec8b30cf..3765c3b50 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1760,11 +1760,11 @@ std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquatio void Generator::GeneratorImpl::addInterfaceComputeModelMethodsCode() { - auto interfaceInitialiseVariablesMethodString = mProfile->interfaceInitialiseVariablesMethodString(modelHasOdes()); + auto interfaceInitialiseArraysMethodString = mProfile->interfaceInitialiseArraysMethodString(modelHasOdes()); std::string code; - if (!interfaceInitialiseVariablesMethodString.empty()) { - code += interfaceInitialiseVariablesMethodString; + if (!interfaceInitialiseArraysMethodString.empty()) { + code += interfaceInitialiseArraysMethodString; } if (!mProfile->interfaceComputeComputedConstantsMethodString().empty()) { @@ -1816,11 +1816,11 @@ std::string Generator::GeneratorImpl::generateConstantInitialisationCode(const s return code; } -void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(std::vector &remainingEquations) +void Generator::GeneratorImpl::addImplementationInitialiseArraysMethodCode(std::vector &remainingEquations) { - auto implementationInitialiseVariablesMethodString = mProfile->implementationInitialiseVariablesMethodString(modelHasOdes()); + auto implementationInitialiseArraysMethodString = mProfile->implementationInitialiseArraysMethodString(modelHasOdes()); - if (!implementationInitialiseVariablesMethodString.empty()) { + if (!implementationInitialiseArraysMethodString.empty()) { // Initialise our states (after, if needed, initialising the constant on which it depends). std::string methodBody; @@ -1887,7 +1887,7 @@ void Generator::GeneratorImpl::addImplementationInitialiseVariablesMethodCode(st } mCode += newLineIfNeeded() - + replace(implementationInitialiseVariablesMethodString, + + replace(implementationInitialiseArraysMethodString, "[CODE]", generateMethodBodyCode(methodBody)); } } @@ -2104,12 +2104,12 @@ std::string Generator::implementationCode() const mPimpl->addExternNlaSolveMethodCode(); mPimpl->addNlaSystemsCode(); - // Add code for the implementation to initialise our variables. + // Add code for the implementation to initialise our arrays. auto equations = mPimpl->mModel->equations(); std::vector remainingEquations {std::begin(equations), std::end(equations)}; - mPimpl->addImplementationInitialiseVariablesMethodCode(remainingEquations); + mPimpl->addImplementationInitialiseArraysMethodCode(remainingEquations); // Add code for the implementation to compute our computed constants. diff --git a/src/generator_p.h b/src/generator_p.h index 16f603b5e..30ca287fd 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -140,7 +140,7 @@ struct Generator::GeneratorImpl void addInterfaceComputeModelMethodsCode(); std::string generateConstantInitialisationCode(const std::vector::iterator constant, std::vector &remainingConstants); - void addImplementationInitialiseVariablesMethodCode(std::vector &remainingEquations); + void addImplementationInitialiseArraysMethodCode(std::vector &remainingEquations); void addImplementationComputeComputedConstantsMethodCode(std::vector &remainingEquations); void addImplementationComputeRatesMethodCode(std::vector &remainingEquations); void addImplementationComputeVariablesMethodCode(std::vector &remainingEquations); diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 353a1da06..ba3ecff76 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -477,17 +477,17 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi " free(array);\n" "}\n"; - mInterfaceInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables);\n"; - mImplementationInitialiseVariablesMethodFamString = "void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables)\n" - "{\n" - "[CODE]" - "}\n"; - - mInterfaceInitialiseVariablesMethodFdmString = "void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n"; - mImplementationInitialiseVariablesMethodFdmString = "void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n" - "{\n" - "[CODE]" - "}\n"; + mInterfaceInitialiseArraysMethodFamString = "void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables);\n"; + mImplementationInitialiseArraysMethodFamString = "void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables)\n" + "{\n" + "[CODE]" + "}\n"; + + mInterfaceInitialiseArraysMethodFdmString = "void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n"; + mImplementationInitialiseArraysMethodFdmString = "void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n" + "{\n" + "[CODE]" + "}\n"; mInterfaceComputeComputedConstantsMethodString = "void computeComputedConstants(double *constants, double *computedConstants);\n"; mImplementationComputeComputedConstantsMethodString = "void computeComputedConstants(double *constants, double *computedConstants)\n" @@ -913,15 +913,15 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi mInterfaceDeleteArrayMethodString = ""; mImplementationDeleteArrayMethodString = ""; - mInterfaceInitialiseVariablesMethodFamString = ""; - mImplementationInitialiseVariablesMethodFamString = "\n" - "def initialise_variables(constants, computed_constants, algebraic_variables):\n" - "[CODE]"; + mInterfaceInitialiseArraysMethodFamString = ""; + mImplementationInitialiseArraysMethodFamString = "\n" + "def initialise_arrays(constants, computed_constants, algebraic_variables):\n" + "[CODE]"; - mInterfaceInitialiseVariablesMethodFdmString = ""; - mImplementationInitialiseVariablesMethodFdmString = "\n" - "def initialise_variables(states, rates, constants, computed_constants, algebraic_variables):\n" - "[CODE]"; + mInterfaceInitialiseArraysMethodFdmString = ""; + mImplementationInitialiseArraysMethodFdmString = "\n" + "def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables):\n" + "[CODE]"; mInterfaceComputeComputedConstantsMethodString = ""; mImplementationComputeComputedConstantsMethodString = "\n" @@ -2764,41 +2764,41 @@ void GeneratorProfile::setImplementationDeleteArrayMethodString(const std::strin mPimpl->mImplementationDeleteArrayMethodString = implementationDeleteArrayMethodString; } -std::string GeneratorProfile::interfaceInitialiseVariablesMethodString(bool forDifferentialModel) const +std::string GeneratorProfile::interfaceInitialiseArraysMethodString(bool forDifferentialModel) const { if (forDifferentialModel) { - return mPimpl->mInterfaceInitialiseVariablesMethodFdmString; + return mPimpl->mInterfaceInitialiseArraysMethodFdmString; } - return mPimpl->mInterfaceInitialiseVariablesMethodFamString; + return mPimpl->mInterfaceInitialiseArraysMethodFamString; } -void GeneratorProfile::setInterfaceInitialiseVariablesMethodString(bool forDifferentialModel, - const std::string &interfaceInitialiseVariablesMethodString) +void GeneratorProfile::setInterfaceInitialiseArraysMethodString(bool forDifferentialModel, + const std::string &interfaceInitialiseArraysMethodString) { if (forDifferentialModel) { - mPimpl->mInterfaceInitialiseVariablesMethodFdmString = interfaceInitialiseVariablesMethodString; + mPimpl->mInterfaceInitialiseArraysMethodFdmString = interfaceInitialiseArraysMethodString; } else { - mPimpl->mInterfaceInitialiseVariablesMethodFamString = interfaceInitialiseVariablesMethodString; + mPimpl->mInterfaceInitialiseArraysMethodFamString = interfaceInitialiseArraysMethodString; } } -std::string GeneratorProfile::implementationInitialiseVariablesMethodString(bool forDifferentialModel) const +std::string GeneratorProfile::implementationInitialiseArraysMethodString(bool forDifferentialModel) const { if (forDifferentialModel) { - return mPimpl->mImplementationInitialiseVariablesMethodFdmString; + return mPimpl->mImplementationInitialiseArraysMethodFdmString; } - return mPimpl->mImplementationInitialiseVariablesMethodFamString; + return mPimpl->mImplementationInitialiseArraysMethodFamString; } -void GeneratorProfile::setImplementationInitialiseVariablesMethodString(bool forDifferentialModel, - const std::string &implementationInitialiseVariablesMethodString) +void GeneratorProfile::setImplementationInitialiseArraysMethodString(bool forDifferentialModel, + const std::string &implementationInitialiseArraysMethodString) { if (forDifferentialModel) { - mPimpl->mImplementationInitialiseVariablesMethodFdmString = implementationInitialiseVariablesMethodString; + mPimpl->mImplementationInitialiseArraysMethodFdmString = implementationInitialiseArraysMethodString; } else { - mPimpl->mImplementationInitialiseVariablesMethodFamString = implementationInitialiseVariablesMethodString; + mPimpl->mImplementationInitialiseArraysMethodFamString = implementationInitialiseArraysMethodString; } } diff --git a/src/generatorprofile_p.h b/src/generatorprofile_p.h index f27bdee89..1c521beac 100644 --- a/src/generatorprofile_p.h +++ b/src/generatorprofile_p.h @@ -273,11 +273,11 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mInterfaceDeleteArrayMethodString; std::string mImplementationDeleteArrayMethodString; - std::string mInterfaceInitialiseVariablesMethodFamString; - std::string mImplementationInitialiseVariablesMethodFamString; + std::string mInterfaceInitialiseArraysMethodFamString; + std::string mImplementationInitialiseArraysMethodFamString; - std::string mInterfaceInitialiseVariablesMethodFdmString; - std::string mImplementationInitialiseVariablesMethodFdmString; + std::string mInterfaceInitialiseArraysMethodFdmString; + std::string mImplementationInitialiseArraysMethodFdmString; std::string mInterfaceComputeComputedConstantsMethodString; std::string mImplementationComputeComputedConstantsMethodString; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 81570372b..cc8bbdfa4 100644 --- a/src/generatorprofilesha1values.h +++ b/src/generatorprofilesha1values.h @@ -24,7 +24,7 @@ namespace libcellml { * The content of this file is generated, do not edit this file directly. * See docs/dev_utilities.rst for further information. */ -static const char C_GENERATOR_PROFILE_SHA1[] = "35703a49bbac407bd614743267eafea5ca1310ef"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "68c4de7463e2319e5626d83d71b1d1dc34c446b7"; +static const char C_GENERATOR_PROFILE_SHA1[] = "a28f116b9c131ab67a9a3edf888a6773cb4659e3"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "15465afc1abac9cf85d9a7a6c16ee86c28de4046"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index 81937a821..7226cacaa 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -533,11 +533,11 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->interfaceDeleteArrayMethodString() + generatorProfile->implementationDeleteArrayMethodString(); - profileContents += generatorProfile->interfaceInitialiseVariablesMethodString(false) - + generatorProfile->implementationInitialiseVariablesMethodString(false); + profileContents += generatorProfile->interfaceInitialiseArraysMethodString(false) + + generatorProfile->implementationInitialiseArraysMethodString(false); - profileContents += generatorProfile->interfaceInitialiseVariablesMethodString(true) - + generatorProfile->implementationInitialiseVariablesMethodString(true); + profileContents += generatorProfile->interfaceInitialiseArraysMethodString(true) + + generatorProfile->implementationInitialiseArraysMethodString(true); profileContents += generatorProfile->interfaceComputeComputedConstantsMethodString() + generatorProfile->implementationComputeComputedConstantsMethodString(); diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index 0686dab2a..e6f6c8aec 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -1041,23 +1041,23 @@ describe("GeneratorProfile tests", () => { x.setImplementationDeleteArrayMethodString("something") expect(x.implementationDeleteArrayMethodString()).toBe("something") }); - test("Checking GeneratorProfile.interfaceInitialiseVariablesMethodString.", () => { + test("Checking GeneratorProfile.interfaceInitialiseArraysMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceInitialiseVariablesMethodString(false, "something") - expect(x.interfaceInitialiseVariablesMethodString(false)).toBe("something") + x.setInterfaceInitialiseArraysMethodString(false, "something") + expect(x.interfaceInitialiseArraysMethodString(false)).toBe("something") - x.setInterfaceInitialiseVariablesMethodString(true, "something") - expect(x.interfaceInitialiseVariablesMethodString(true)).toBe("something") + x.setInterfaceInitialiseArraysMethodString(true, "something") + expect(x.interfaceInitialiseArraysMethodString(true)).toBe("something") }); - test("Checking GeneratorProfile.implementationInitialiseVariablesMethodString.", () => { + test("Checking GeneratorProfile.implementationInitialiseArraysMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationInitialiseVariablesMethodString(false, "something") - expect(x.implementationInitialiseVariablesMethodString(false)).toBe("something") + x.setImplementationInitialiseArraysMethodString(false, "something") + expect(x.implementationInitialiseArraysMethodString(false)).toBe("something") - x.setImplementationInitialiseVariablesMethodString(true, "something") - expect(x.implementationInitialiseVariablesMethodString(true)).toBe("something") + x.setImplementationInitialiseArraysMethodString(true, "something") + expect(x.implementationInitialiseArraysMethodString(true)).toBe("something") }); test("Checking GeneratorProfile.interfaceComputeComputedConstantsMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) diff --git a/tests/bindings/python/test_generator_profile.py b/tests/bindings/python/test_generator_profile.py index a564c4711..a4fb566a0 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -838,15 +838,15 @@ def test_implementation_initialise_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables)\n{\n[CODE]}\n', - g.implementationInitialiseVariablesMethodString(False)) - g.setImplementationInitialiseVariablesMethodString(False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(False)) + self.assertEqual('void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables)\n{\n[CODE]}\n', + g.implementationInitialiseArraysMethodString(False)) + g.setImplementationInitialiseArraysMethodString(False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseArraysMethodString(False)) - self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n{\n[CODE]}\n', - g.implementationInitialiseVariablesMethodString(True)) - g.setImplementationInitialiseVariablesMethodString(True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseVariablesMethodString(True)) + self.assertEqual('void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n{\n[CODE]}\n', + g.implementationInitialiseArraysMethodString(True)) + g.setImplementationInitialiseArraysMethodString(True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationInitialiseArraysMethodString(True)) def test_implementation_libcellml_version_string(self): from libcellml import GeneratorProfile @@ -1117,15 +1117,15 @@ def test_interface_initialise_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables);\n', - g.interfaceInitialiseVariablesMethodString(False)) - g.setInterfaceInitialiseVariablesMethodString(False, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(False)) + self.assertEqual('void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables);\n', + g.interfaceInitialiseArraysMethodString(False)) + g.setInterfaceInitialiseArraysMethodString(False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseArraysMethodString(False)) - self.assertEqual('void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n', - g.interfaceInitialiseVariablesMethodString(True)) - g.setInterfaceInitialiseVariablesMethodString(True, GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseVariablesMethodString(True)) + self.assertEqual('void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n', + g.interfaceInitialiseArraysMethodString(True)) + g.setInterfaceInitialiseArraysMethodString(True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceInitialiseArraysMethodString(True)) def test_interface_libcellml_version_string(self): from libcellml import GeneratorProfile diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 0f933ffe7..3de30bb07 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -757,8 +757,8 @@ TEST(Coverage, generator) profile->setImplementationDeleteArrayMethodString(""); - profile->setImplementationInitialiseVariablesMethodString(false, ""); - profile->setImplementationInitialiseVariablesMethodString(true, ""); + profile->setImplementationInitialiseArraysMethodString(false, ""); + profile->setImplementationInitialiseArraysMethodString(true, ""); profile->setImplementationComputeVariablesMethodString(false, false, ""); profile->setImplementationComputeVariablesMethodString(false, true, ""); diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index ebef497d6..a17b6165f 100644 --- a/tests/generator/generatorprofile.cpp +++ b/tests/generator/generatorprofile.cpp @@ -558,21 +558,21 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationDeleteArrayMethodString()); - EXPECT_EQ("void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables);\n", - generatorProfile->interfaceInitialiseVariablesMethodString(false)); - EXPECT_EQ("void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables)\n" + EXPECT_EQ("void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables);\n", + generatorProfile->interfaceInitialiseArraysMethodString(false)); + EXPECT_EQ("void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" "[CODE]" "}\n", - generatorProfile->implementationInitialiseVariablesMethodString(false)); + generatorProfile->implementationInitialiseArraysMethodString(false)); - EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n", - generatorProfile->interfaceInitialiseVariablesMethodString(true)); - EXPECT_EQ("void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n" + EXPECT_EQ("void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n", + generatorProfile->interfaceInitialiseArraysMethodString(true)); + EXPECT_EQ("void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables)\n" "{\n" "[CODE]" "}\n", - generatorProfile->implementationInitialiseVariablesMethodString(true)); + generatorProfile->implementationInitialiseArraysMethodString(true)); EXPECT_EQ("void computeComputedConstants(double *constants, double *computedConstants);\n", generatorProfile->interfaceComputeComputedConstantsMethodString()); @@ -1051,11 +1051,11 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setInterfaceDeleteArrayMethodString(value); generatorProfile->setImplementationDeleteArrayMethodString(value); - generatorProfile->setInterfaceInitialiseVariablesMethodString(false, value); - generatorProfile->setInterfaceInitialiseVariablesMethodString(true, value); + generatorProfile->setInterfaceInitialiseArraysMethodString(false, value); + generatorProfile->setInterfaceInitialiseArraysMethodString(true, value); - generatorProfile->setImplementationInitialiseVariablesMethodString(false, value); - generatorProfile->setImplementationInitialiseVariablesMethodString(true, value); + generatorProfile->setImplementationInitialiseArraysMethodString(false, value); + generatorProfile->setImplementationInitialiseArraysMethodString(true, value); generatorProfile->setInterfaceComputeComputedConstantsMethodString(value); generatorProfile->setImplementationComputeComputedConstantsMethodString(value); @@ -1206,11 +1206,11 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->interfaceDeleteArrayMethodString()); EXPECT_EQ(value, generatorProfile->implementationDeleteArrayMethodString()); - EXPECT_EQ(value, generatorProfile->interfaceInitialiseVariablesMethodString(false)); - EXPECT_EQ(value, generatorProfile->implementationInitialiseVariablesMethodString(false)); + EXPECT_EQ(value, generatorProfile->interfaceInitialiseArraysMethodString(false)); + EXPECT_EQ(value, generatorProfile->implementationInitialiseArraysMethodString(false)); - EXPECT_EQ(value, generatorProfile->interfaceInitialiseVariablesMethodString(true)); - EXPECT_EQ(value, generatorProfile->implementationInitialiseVariablesMethodString(true)); + EXPECT_EQ(value, generatorProfile->interfaceInitialiseArraysMethodString(true)); + EXPECT_EQ(value, generatorProfile->implementationInitialiseArraysMethodString(true)); EXPECT_EQ(value, generatorProfile->interfaceComputeComputedConstantsMethodString()); EXPECT_EQ(value, generatorProfile->implementationComputeComputedConstantsMethodString()); diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 59623d2dd..48bc8bae9 100644 --- a/tests/resources/coverage/generator/model.c +++ b/tests/resources/coverage/generator/model.c @@ -426,7 +426,7 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou algebraicVariables[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; constants[0] = 1.23; diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 97423973a..0b1610cf2 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/coverage/generator/model.implementation.out b/tests/resources/coverage/generator/model.implementation.out index f78a1029c..0b6ee7a96 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -185,7 +185,7 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou algebraicVariables[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; constants[0] = 1.23; diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index a42db6021..459251ef5 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -14,7 +14,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/coverage/generator/model.modified.profile.c b/tests/resources/coverage/generator/model.modified.profile.c index ce4cbac5b..12bf8f9f4 100644 --- a/tests/resources/coverage/generator/model.modified.profile.c +++ b/tests/resources/coverage/generator/model.modified.profile.c @@ -426,7 +426,7 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou algebraicVariables[1] = u[1]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; constants[0] = 1.23; diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 2dc0c3178..77991ad33 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/coverage/generator/model.modified.profile.py b/tests/resources/coverage/generator/model.modified.profile.py index 0d6c52b57..16d3c08fe 100644 --- a/tests/resources/coverage/generator/model.modified.profile.py +++ b/tests/resources/coverage/generator/model.modified.profile.py @@ -394,7 +394,7 @@ def find_root_0(voi, states, rates, constants, computed_constants, algebraic_var algebraicVariables[1] = u[1] -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 constants[0] = 1.23 constants[1] = 123.0 diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index 536ff31f0..dbb1353a1 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -394,7 +394,7 @@ def find_root_0(voi, states, rates, constants, computed_constants, algebraic_var algebraicVariables[1] = u[1] -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 constants[0] = 1.23 constants[1] = 123.0 diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c index 8236dea1a..0d262c114 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.c @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c index 66710d411..8fae406da 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.c @@ -76,7 +76,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h index c6a20ed23..2fb36a41e 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py index 116142e91..4ed975a6e 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.external.py @@ -43,7 +43,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h index 56505017d..4dcfcab4a 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py index 80d464663..9d19e312a 100644 --- a/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_computed_var_on_rhs/model.py @@ -35,7 +35,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c index 6656fcabb..59ee86aa4 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.c @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h index 56505017d..4dcfcab4a 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py index a7d6c15c3..49883c3b6 100644 --- a/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_const_var_on_rhs/model.py @@ -35,7 +35,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c index 3ed487d06..b06c5d19f 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.c @@ -60,7 +60,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h index 1aa5136cc..126c1fa4f 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py index 2a1433127..9048472b8 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.py @@ -34,7 +34,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c index 8f8e8fe01..56bd1d6f4 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h index 7f0d4418e..6b987acfa 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py index a331fb1e0..a20e58056 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.py @@ -46,7 +46,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c index 4d871f841..90b199574 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h index 61940eb44..96e644acb 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py index 4d2f1fb8f..04f0a3bcd 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c index e62b78e41..919d0f708 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h index a5586f626..f1706e395 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py index a47d25b06..765d530d9 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs/model.py @@ -46,7 +46,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c index 498fb9add..e38c1c984 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index 954a5c239..978a2504b 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py index 34f37edb7..2a578c3b2 100644 --- a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c index bb0fdb72a..40fe403a2 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.c @@ -95,7 +95,7 @@ void findRoot0(double *constants, double *computedConstants, double *algebraicVa algebraicVariables[0] = u[0]; } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 3.0; computedConstants[1] = 5.0; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c index 3c6de9052..f3484140c 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.c @@ -112,7 +112,7 @@ void findRoot0(double *constants, double *computedConstants, double *algebraicVa algebraicVariables[0] = u[0]; } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 3.0; computedConstants[1] = 7.0; diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h index c6a20ed23..2fb36a41e 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py index b300a1abb..049466b7a 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py @@ -69,7 +69,7 @@ def find_root_0(constants, computed_constants, algebraic_variables, external_var algebraicVariables[0] = u[0] -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): computed_constants[0] = 3.0 computed_constants[1] = 7.0 algebraicVariables[0] = 1.0 diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h index 56505017d..4dcfcab4a 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.h @@ -27,6 +27,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py index bf6400289..5f14d3687 100644 --- a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown/model.py @@ -60,7 +60,7 @@ def find_root_0(constants, computed_constants, algebraic_variables): algebraicVariables[0] = u[0] -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): computed_constants[0] = 3.0 computed_constants[1] = 5.0 computed_constants[2] = 7.0 diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c index a4373bc28..fdeba2473 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.c @@ -102,7 +102,7 @@ void findRoot0(double *constants, double *computedConstants, double *algebraicVa algebraicVariables[2] = u[2]; } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { algebraicVariables[0] = 1.0; algebraicVariables[1] = 1.0; diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c index 7f9e8d52d..1b857ca9b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h index a976b36a9..9d078e44a 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py index f0201f4a1..2be054c9b 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.external.py @@ -44,7 +44,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h index f8a633bbc..569c6e639 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.h @@ -27,6 +27,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py index 2514ba0f2..b8a9dba6c 100644 --- a/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py +++ b/tests/resources/generator/algebraic_system_with_three_linked_unknowns/model.py @@ -67,7 +67,7 @@ def find_root_0(constants, computed_constants, algebraic_variables): algebraicVariables[2] = u[2] -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): algebraicVariables[0] = 1.0 algebraicVariables[1] = 1.0 algebraicVariables[2] = 1.0 diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c index 17996b6af..a238da57d 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.c @@ -101,7 +101,7 @@ void findRoot0(double *constants, double *computedConstants, double *algebraicVa algebraicVariables[1] = u[1]; } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 5.0; constants[1] = 3.0; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h index f8a633bbc..569c6e639 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.h @@ -27,6 +27,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py index 9c8678d24..44f399a55 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.not.ordered.py @@ -66,7 +66,7 @@ def find_root_0(constants, computed_constants, algebraic_variables): algebraicVariables[1] = u[1] -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): constants[0] = 5.0 constants[1] = 3.0 algebraicVariables[0] = 1.0 diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c index 23ee83b1c..09c61e959 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.c @@ -101,7 +101,7 @@ void findRoot0(double *constants, double *computedConstants, double *algebraicVa algebraicVariables[1] = u[1]; } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 5.0; constants[1] = 3.0; diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h index f8a633bbc..569c6e639 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.h @@ -27,6 +27,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py index 9c8678d24..44f399a55 100644 --- a/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py +++ b/tests/resources/generator/algebraic_system_with_various_dependencies/model.ordered.py @@ -66,7 +66,7 @@ def find_root_0(constants, computed_constants, algebraic_variables): algebraicVariables[1] = u[1] -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): constants[0] = 5.0 constants[1] = 3.0 algebraicVariables[0] = 1.0 diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c index 6488fe2dd..ed963bc27 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.c @@ -61,7 +61,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { computedConstants[0] = 1.0; } diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h index 1aa5136cc..126c1fa4f 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -27,6 +27,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py index 82bea886a..23749765f 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.py @@ -35,7 +35,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): computed_constants[0] = 1.0 diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index e1048017a..6157e4506 100644 --- a/tests/resources/generator/cell_geometry_model/model.c +++ b/tests/resources/generator/cell_geometry_model/model.c @@ -63,7 +63,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 0.01; constants[1] = 0.0011; diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 35e13ec58..50075b8ac 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.c +++ b/tests/resources/generator/cell_geometry_model/model.external.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { } diff --git a/tests/resources/generator/cell_geometry_model/model.external.h b/tests/resources/generator/cell_geometry_model/model.external.h index 597046bab..996b0c5b7 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.h +++ b/tests/resources/generator/cell_geometry_model/model.external.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/cell_geometry_model/model.external.py b/tests/resources/generator/cell_geometry_model/model.external.py index 57835e297..2d6901939 100644 --- a/tests/resources/generator/cell_geometry_model/model.external.py +++ b/tests/resources/generator/cell_geometry_model/model.external.py @@ -45,7 +45,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): pass diff --git a/tests/resources/generator/cell_geometry_model/model.h b/tests/resources/generator/cell_geometry_model/model.h index 6487ae239..4c874d7d3 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -27,6 +27,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cell_geometry_model/model.py b/tests/resources/generator/cell_geometry_model/model.py index 1fae0dca9..2dbeb7479 100644 --- a/tests/resources/generator/cell_geometry_model/model.py +++ b/tests/resources/generator/cell_geometry_model/model.py @@ -37,7 +37,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): constants[0] = 0.01 constants[1] = 0.0011 diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 25d8af002..472c993e5 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index 3c70ec191..fe608b36b 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py index 9f063568b..408edc8d3 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.py +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.py @@ -47,7 +47,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 states[1] = 0.0 diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index 579c8df29..d5e8abd2e 100644 --- a/tests/resources/generator/cellml_slc_example/model.py +++ b/tests/resources/generator/cellml_slc_example/model.py @@ -43,7 +43,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): constants[0] = 810000.0 constants[1] = 150.0 constants[2] = 2.0 diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_state_initialised_using_variable/model.c index d7252d5af..862fd4f89 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 123.0; states[0] = constants[0]; diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_state_initialised_using_variable/model.h index b5a9edb2f..c6487c76f 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_state_initialised_using_variable/model.py index 8c3c8e3fd..a6e1be779 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.py @@ -45,7 +45,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): constants[0] = 123.0 states[0] = constants[0] diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.c b/tests/resources/generator/cellml_unit_scaling_constant/model.c index 9325bc1fe..9c8ec8a7d 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { constants[2] = 123.0; constants[1] = constants[2]; diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index a7ad0b8ef..9f71954f0 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -27,6 +27,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.py b/tests/resources/generator/cellml_unit_scaling_constant/model.py index 0a51c8e9c..35eaab670 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.py @@ -52,7 +52,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): constants[2] = 123.0 constants[1] = constants[2] constants[0] = constants[1] diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 7f0ba89f9..5183826b8 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.c +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index b5a9edb2f..c6487c76f 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.py b/tests/resources/generator/cellml_unit_scaling_rate/model.py index a909701f7..e09640d63 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.py +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.py @@ -46,7 +46,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index e4dafe1a9..f845f9eb5 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 123.0; } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index b5a9edb2f..c6487c76f 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.py b/tests/resources/generator/cellml_unit_scaling_state/model.py index fa3fdde88..c4bf88dee 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state/model.py @@ -46,7 +46,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 123.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c index b1a893402..05db1e4de 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 123.0; states[1] = 0.001*789.0; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h index cb00e12cd..c95a25b64 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py index 3c776abce..6dd25d580 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_constant/model.py @@ -45,7 +45,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 123.0 states[1] = 0.001*789.0 diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c index 246aed9c9..0765e8101 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.c @@ -80,7 +80,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 123.0; states[0] = constants[0]; diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h index 1712c68d5..5f761c9c0 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py index 11b86584f..4615bfe54 100644 --- a/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py +++ b/tests/resources/generator/cellml_unit_scaling_state_initialised_using_variable/model.py @@ -47,7 +47,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): constants[0] = 123.0 states[0] = constants[0] constants[1] = 789.0 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c index b965e14f2..f71689854 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 3.0; states[1] = 5.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h index 41e5207c3..43d59a6ac 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py index d7f40ed86..da0cfff50 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.py @@ -45,7 +45,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 3.0 states[1] = 5.0 diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c index b5890c16d..885239e91 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 3.0; states[1] = 7.0; diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h index 34face41a..6889a0f88 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py index e640409c5..9db84ae67 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.py @@ -46,7 +46,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 3.0 states[1] = 7.0 states[2] = 11.0 diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 809229dc1..46bce59ed 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -152,7 +152,7 @@ void findRoot1(double voi, double *states, double *rates, double *constants, dou algebraicVariables[2] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; states[1] = 0.0; diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.h b/tests/resources/generator/dae_cellml_1_1_model/model.h index 3251075ec..56c4ec8f9 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index bc047295b..85e0f1168 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -104,7 +104,7 @@ def find_root_1(voi, states, rates, constants, computed_constants, algebraic_var algebraicVariables[2] = u[0] -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 states[1] = 0.0 constants[0] = 1.0 diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 7564c3950..52a35d323 100644 --- a/tests/resources/generator/dependent_eqns/model.c +++ b/tests/resources/generator/dependent_eqns/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 785cd94aa..72a91e08c 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/dependent_eqns/model.py b/tests/resources/generator/dependent_eqns/model.py index 7ecaeb08d..ffa8c9899 100644 --- a/tests/resources/generator/dependent_eqns/model.py +++ b/tests/resources/generator/dependent_eqns/model.py @@ -46,7 +46,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index a7a730710..c99065686 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -326,7 +326,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 6.226104e-5; states[1] = 5.0; diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h index 0c9ef320b..bb7470ed3 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 9bcd8da76..0649afbd9 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -313,7 +313,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 6.226104e-5 states[1] = 5.0 states[2] = 0.409551 diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index 6e1406536..206a7a19e 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -276,7 +276,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = -39.013558536; states[1] = 0.092361701692; diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h index 7c2eecaec..b011ffab7 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index d8f15a60d..d49191f67 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -251,7 +251,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = -39.013558536 states[1] = 0.092361701692 states[2] = 0.01445216109 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index d62e741c3..0e84cef0a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h index 03a57c1b3..6a2c1df8d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 269ccdff7..351219dc8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -85,7 +85,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index cdffa09a4..b1d4c789e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -98,7 +98,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 6a45ce5c8..5e1a8d0d0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h index 03a57c1b3..6a2c1df8d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index a9da5eb92..77394c2ad 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -85,7 +85,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 2eb4c0918..889846a3e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h index 03a57c1b3..6a2c1df8d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 23c0e7ad8..b147860cd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -85,7 +85,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 8c082c2dc..a1e5d1cc1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -552,7 +552,7 @@ void findRoot16(double voi, double *states, double *rates, double *constants, do rates[3] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c index 336e0410b..5d40e144b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c @@ -504,7 +504,7 @@ void findRoot16(double voi, double *states, double *rates, double *constants, do rates[2] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.6; states[1] = 0.05; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h index 03a57c1b3..6a2c1df8d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py index e139cb306..4b05be018 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py @@ -424,7 +424,7 @@ def find_root_16(voi, states, rates, constants, computed_constants, algebraic_va rates[2] = u[0] -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.6 states[1] = 0.05 states[2] = 0.325 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h index 60d6aae86..52fbb522e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index e2b90a51e..db09917cb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -471,7 +471,7 @@ def find_root_16(voi, states, rates, constants, computed_constants, algebraic_va rates[3] = u[0] -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index f42289959..b927af008 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h index 03a57c1b3..6a2c1df8d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index 5c0c635c5..05eb94ed4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -85,7 +85,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 3d4d1e641..929550fc1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h index 03a57c1b3..6a2c1df8d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index 0057a9d4f..1429a1bbf 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -85,7 +85,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index 313cb516d..d891eb72a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h index 03a57c1b3..6a2c1df8d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 8563cc59c..597f6adbc 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -85,7 +85,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index e5d1dd95b..2b81fde4d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.6; states[1] = 0.325; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h index 03a57c1b3..6a2c1df8d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index 80a764c9b..e48cefc1f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -85,7 +85,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.6 states[1] = 0.325 constants[0] = 1.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index 78967f2ea..792764a3d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.6; states[1] = 0.05; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h index 03a57c1b3..6a2c1df8d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 0bb06126a..8552db8b4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -85,7 +85,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.6 states[1] = 0.05 states[2] = 0.325 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h index 60d6aae86..52fbb522e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index 10f53f996..3a651041f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -77,7 +77,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.05 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 0ee5fa70b..f59bbb56e 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -113,7 +113,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.6; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h index 03a57c1b3..6a2c1df8d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.h @@ -36,7 +36,7 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index 9242260cd..ab871e5b5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -85,7 +85,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.6 states[2] = 0.325 diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 0ab3de18e..9fc9798f8 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -97,7 +97,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = -87.0; states[1] = 0.8; diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index 912f18c9c..b74431288 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index a9d7b2fd2..c92f3a003 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -64,7 +64,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = -87.0 states[1] = 0.8 states[2] = 0.01 diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.c b/tests/resources/generator/ode_computed_var_on_rhs/model.c index d919490b2..cf60492fe 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.h b/tests/resources/generator/ode_computed_var_on_rhs/model.h index 41e5207c3..43d59a6ac 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_computed_var_on_rhs/model.py b/tests/resources/generator/ode_computed_var_on_rhs/model.py index 0ec4edf87..9d0b2be18 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c index c2d619c92..330c16771 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; computedConstants[0] = 1.0; diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h index 61940eb44..96e644acb 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py index 51ebe69f5..94fbbc54d 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_computed_var_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 computed_constants[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.c b/tests/resources/generator/ode_const_var_on_rhs/model.c index a0a79e7b1..bcf158ba5 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; constants[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.h b/tests/resources/generator/ode_const_var_on_rhs/model.h index 41e5207c3..43d59a6ac 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_const_var_on_rhs/model.py b/tests/resources/generator/ode_const_var_on_rhs/model.py index f6dae349b..40e251e63 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c index d3191eb73..b2bd749a5 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; constants[0] = 1.0; diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h index 61940eb44..96e644acb 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py index 87b5e723e..d3f6ac0b0 100644 --- a/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_const_var_on_rhs_one_component/model.py @@ -45,7 +45,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs/model.c b/tests/resources/generator/ode_constant_on_rhs/model.c index be1ec403c..810d635e1 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.c +++ b/tests/resources/generator/ode_constant_on_rhs/model.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs/model.h b/tests/resources/generator/ode_constant_on_rhs/model.h index 41e5207c3..43d59a6ac 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_constant_on_rhs/model.py b/tests/resources/generator/ode_constant_on_rhs/model.py index 69737da89..4c9fb6d21 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.py +++ b/tests/resources/generator/ode_constant_on_rhs/model.py @@ -44,7 +44,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c index 2ffb9c96d..623f57694 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.c +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.c @@ -77,7 +77,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; } diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h index 61940eb44..96e644acb 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.h +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py index 08c6b083b..f27c0dcfd 100644 --- a/tests/resources/generator/ode_constant_on_rhs_one_component/model.py +++ b/tests/resources/generator/ode_constant_on_rhs_one_component/model.py @@ -44,7 +44,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.c b/tests/resources/generator/ode_multiple_dependent_odes/model.c index dbea529dc..f4dc722df 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = -2.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.h b/tests/resources/generator/ode_multiple_dependent_odes/model.h index 482289ea6..cf9be194a 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_multiple_dependent_odes/model.py b/tests/resources/generator/ode_multiple_dependent_odes/model.py index 596d4e98d..e31e573c3 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.py @@ -46,7 +46,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = -2.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c index 350f26c85..521cdf660 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = -2.0; diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h index c20a5bbd2..163aabdf6 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py index 34967078d..815015047 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py +++ b/tests/resources/generator/ode_multiple_dependent_odes_one_component/model.py @@ -46,7 +46,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = -2.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c index 007963343..9c3238c6d 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.c +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.c @@ -79,7 +79,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; states[1] = 1.0; diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h index 798b00b58..d8e9cf382 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.h +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py index fa585da0d..5078cadfe 100644 --- a/tests/resources/generator/ode_multiple_odes_with_same_name/model.py +++ b/tests/resources/generator/ode_multiple_odes_with_same_name/model.py @@ -46,7 +46,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 states[1] = 1.0 constants[0] = 1.0 diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.c b/tests/resources/generator/ode_unknown_var_on_rhs/model.c index 152cd7be9..290255580 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.c +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 1.0; states[1] = 1.0; diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.h b/tests/resources/generator/ode_unknown_var_on_rhs/model.h index 41e5207c3..43d59a6ac 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_unknown_var_on_rhs/model.py b/tests/resources/generator/ode_unknown_var_on_rhs/model.py index 92eede813..ce780d7b1 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.py +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.py @@ -45,7 +45,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 1.0 states[1] = 1.0 diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index b504b65ef..023d556f3 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -121,7 +121,7 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou algebraicVariables[0] = u[0]; } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 1.0; diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index bb6472c3a..d4dc2ea10 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 67cbf9550..310f79c87 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -76,7 +76,7 @@ def find_root_0(voi, states, rates, constants, computed_constants, algebraic_var algebraicVariables[0] = u[0] -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 1.0 constants[0] = 1.0e4 diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index df40711df..71cbd395c 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.c +++ b/tests/resources/generator/robertson_model_1966/model.ode.c @@ -83,7 +83,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { states[0] = 0.0; states[1] = 0.0; diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index bb6472c3a..d4dc2ea10 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/robertson_model_1966/model.ode.py b/tests/resources/generator/robertson_model_1966/model.ode.py index 3e64e93a3..e962cff99 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.py +++ b/tests/resources/generator/robertson_model_1966/model.ode.py @@ -50,7 +50,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): states[0] = 0.0 states[1] = 0.0 states[2] = 1.0 diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index d1ba5d822..e60f18fe4 100644 --- a/tests/resources/generator/sine_model_imports/model.c +++ b/tests/resources/generator/sine_model_imports/model.c @@ -87,7 +87,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 0.0; states[0] = constants[0]; diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index 1127d70be..8a0bc26e6 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/sine_model_imports/model.py b/tests/resources/generator/sine_model_imports/model.py index a2db9275f..d6a8ba140 100644 --- a/tests/resources/generator/sine_model_imports/model.py +++ b/tests/resources/generator/sine_model_imports/model.py @@ -58,7 +58,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): constants[0] = 0.0 states[0] = constants[0] constants[1] = 0.75 diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.c b/tests/resources/generator/unknown_variable_as_external_variable/model.c index 48d3ff3e9..75bd0a26d 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.c +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.c @@ -84,7 +84,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 810000.0; constants[1] = 150.0; diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.h b/tests/resources/generator/unknown_variable_as_external_variable/model.h index a8409a3ac..54a014544 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.h +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.h @@ -32,6 +32,6 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); -void initialiseVariables(double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeVariables(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/unknown_variable_as_external_variable/model.py b/tests/resources/generator/unknown_variable_as_external_variable/model.py index 2899f193a..098399d2f 100644 --- a/tests/resources/generator/unknown_variable_as_external_variable/model.py +++ b/tests/resources/generator/unknown_variable_as_external_variable/model.py @@ -51,7 +51,7 @@ def create_external_variables_array(): return [nan]*EXTERNAL_VARIABLE_COUNT -def initialise_variables(constants, computed_constants, algebraic_variables): +def initialise_arrays(constants, computed_constants, algebraic_variables): constants[0] = 810000.0 constants[1] = 150.0 constants[2] = 2.0 diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.c b/tests/resources/generator/variable_initialised_using_a_constant/model.c index 2abddb7f3..1a45dabfe 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.c @@ -78,7 +78,7 @@ void deleteArray(double *array) free(array); } -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { constants[0] = 7.0; states[0] = constants[0]; diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_a_constant/model.h index 51591d2bf..7fd5b729c 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.h @@ -31,7 +31,7 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); -void initialiseVariables(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeComputedConstants(double *constants, double *computedConstants); void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py index 10f33fd7b..2fa0eb819 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ b/tests/resources/generator/variable_initialised_using_a_constant/model.py @@ -45,7 +45,7 @@ def create_algebraic_variables_array(): return [nan]*ALGEBRAIC_VARIABLE_COUNT -def initialise_variables(states, rates, constants, computed_constants, algebraic_variables): +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): constants[0] = 7.0 states[0] = constants[0] From 37e2b7b34b64e1ec810a45d7ed7c2e4662a34fd8 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 5 Nov 2025 22:49:12 +1300 Subject: [PATCH 72/74] CMake: added `analyser_p.h` to `GIT_HEADER_FILES`. --- src/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 1896177c6..baf16cff8 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -121,6 +121,7 @@ set(MODULE_HEADER_FILES ) set(GIT_HEADER_FILES + ${CMAKE_CURRENT_SOURCE_DIR}/analyser_p.h ${CMAKE_CURRENT_SOURCE_DIR}/analyserequation_p.h ${CMAKE_CURRENT_SOURCE_DIR}/analyserequationast_p.h ${CMAKE_CURRENT_SOURCE_DIR}/analyserexternalvariable_p.h From cc143c442f90354ad3088ce68a9ca04d50f74910 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 5 Nov 2025 22:47:44 +1300 Subject: [PATCH 73/74] src/analyser_p.h: removed unneeded header. --- src/analyser_p.h | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/analyser_p.h b/src/analyser_p.h index 254a2ef4c..11e8adbd4 100644 --- a/src/analyser_p.h +++ b/src/analyser_p.h @@ -14,8 +14,6 @@ See the License for the specific language governing permissions and limitations under the License. */ -// #include "libcellml/analyser.h" - #include "analysermodel_p.h" #include "internaltypes.h" #include "issue_p.h" From bd6d67dfebc6d2d5164e8d2c1ca3bccbb1ca477e Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Wed, 5 Nov 2025 23:18:45 +1300 Subject: [PATCH 74/74] Analyser/Generator: some cleaning up around the `libcellml` namespace. --- src/analyser.cpp | 2 +- src/analyser_p.h | 2 +- src/analyserequation.cpp | 4 ++-- src/generator.cpp | 34 +++++++++++++++++----------------- 4 files changed, 21 insertions(+), 21 deletions(-) diff --git a/src/analyser.cpp b/src/analyser.cpp index cd9728a74..50d37e69a 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -766,7 +766,7 @@ void Analyser::AnalyserImpl::analyseNode(const XmlNodePtr &node, auto iter = mStandardUnits.find(unitsName); if (iter == mStandardUnits.end()) { - auto units = libcellml::Units::create(unitsName); + auto units = Units::create(unitsName); mCiCnUnits.emplace(ast, units); mStandardUnits.emplace(unitsName, units); diff --git a/src/analyser_p.h b/src/analyser_p.h index 11e8adbd4..d92224a56 100644 --- a/src/analyser_p.h +++ b/src/analyser_p.h @@ -159,7 +159,7 @@ class Analyser::AnalyserImpl: public Logger::LoggerImpl AnalyserInternalVariablePtrs mInternalVariables; AnalyserInternalEquationPtrs mInternalEquations; - GeneratorProfilePtr mGeneratorProfile = libcellml::GeneratorProfile::create(); + GeneratorProfilePtr mGeneratorProfile = GeneratorProfile::create(); std::map mStandardUnits; std::map mCiCnUnits; diff --git a/src/analyserequation.cpp b/src/analyserequation.cpp index 939f24fe5..93788d6d6 100644 --- a/src/analyserequation.cpp +++ b/src/analyserequation.cpp @@ -31,9 +31,9 @@ AnalyserEquationPtr AnalyserEquation::AnalyserEquationImpl::create() bool AnalyserEquation::AnalyserEquationImpl::isEmptyDependency(const AnalyserEquationWeakPtr &dependency) { - auto variables = libcellml::analyserVariables(dependency.lock()); + auto analyserVariables = libcellml::analyserVariables(dependency.lock()); - if (std::any_of(variables.begin(), variables.end(), [](const auto &v) { return v != nullptr; })) { + if (std::any_of(analyserVariables.begin(), analyserVariables.end(), [](const auto &av) { return av != nullptr; })) { return false; } diff --git a/src/generator.cpp b/src/generator.cpp index 3765c3b50..66549ca08 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -748,15 +748,15 @@ void Generator::GeneratorImpl::addNlaSystemsCode() && (std::find(handledNlaEquations.begin(), handledNlaEquations.end(), equation) == handledNlaEquations.end())) { std::string methodBody; auto i = MAX_SIZE_T; - auto variables = libcellml::analyserVariables(equation); + auto analyserVariables = libcellml::analyserVariables(equation); - for (const auto &variable : variables) { - auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? + for (const auto &analyserVariable : analyserVariables) { + auto arrayString = (analyserVariable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : mProfile->algebraicVariablesArrayString(); methodBody += mProfile->indentString() - + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() + + arrayString + mProfile->openArrayString() + convertToString(analyserVariable->index()) + mProfile->closeArrayString() + mProfile->equalityString() + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() + mProfile->commandSeparatorString() + "\n"; @@ -793,37 +793,37 @@ void Generator::GeneratorImpl::addNlaSystemsCode() i = MAX_SIZE_T; - for (const auto &variable : variables) { - auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? + for (const auto &analyserVariable : analyserVariables) { + auto arrayString = (analyserVariable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : mProfile->algebraicVariablesArrayString(); methodBody += mProfile->indentString() + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() + mProfile->equalityString() - + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() + + arrayString + mProfile->openArrayString() + convertToString(analyserVariable->index()) + mProfile->closeArrayString() + mProfile->commandSeparatorString() + "\n"; } - auto variablesCount = variables.size(); + auto analyserVariablesCount = analyserVariables.size(); methodBody += newLineIfNeeded() + mProfile->indentString() + replace(replace(mProfile->nlaSolveCallString(modelHasOdes(), mModel->hasExternalVariables()), "[INDEX]", convertToString(equation->nlaSystemIndex())), - "[SIZE]", convertToString(variablesCount)); + "[SIZE]", convertToString(analyserVariablesCount)); methodBody += newLineIfNeeded(); i = MAX_SIZE_T; - for (const auto &variable : variables) { - auto arrayString = (variable->type() == AnalyserVariable::Type::STATE) ? + for (const auto &analyserVariable : analyserVariables) { + auto arrayString = (analyserVariable->type() == AnalyserVariable::Type::STATE) ? mProfile->ratesArrayString() : mProfile->algebraicVariablesArrayString(); methodBody += mProfile->indentString() - + arrayString + mProfile->openArrayString() + convertToString(variable->index()) + mProfile->closeArrayString() + + arrayString + mProfile->openArrayString() + convertToString(analyserVariable->index()) + mProfile->closeArrayString() + mProfile->equalityString() + mProfile->uArrayString() + mProfile->openArrayString() + convertToString(++i) + mProfile->closeArrayString() + mProfile->commandSeparatorString() + "\n"; @@ -832,7 +832,7 @@ void Generator::GeneratorImpl::addNlaSystemsCode() mCode += newLineIfNeeded() + replace(replace(replace(mProfile->findRootMethodString(modelHasOdes(), mModel->hasExternalVariables()), "[INDEX]", convertToString(equation->nlaSystemIndex())), - "[SIZE]", convertToString(variablesCount)), + "[SIZE]", convertToString(analyserVariablesCount)), "[CODE]", generateMethodBodyCode(methodBody)); } } @@ -1922,12 +1922,12 @@ void Generator::GeneratorImpl::addImplementationComputeRatesMethodCode(std::vect // NLA equation in case the rate is not on its own on either the LHS // or RHS of the equation. - auto variables = libcellml::analyserVariables(equation); + auto analyserVariables = libcellml::analyserVariables(equation); if ((equation->type() == AnalyserEquation::Type::ODE) || ((equation->type() == AnalyserEquation::Type::NLA) - && (variables.size() == 1) - && (variables[0]->type() == AnalyserVariable::Type::STATE))) { + && (analyserVariables.size() == 1) + && (analyserVariables[0]->type() == AnalyserVariable::Type::STATE))) { methodBody += generateEquationCode(equation, remainingEquations); } } @@ -2136,7 +2136,7 @@ std::string Generator::implementationCode() const std::string Generator::equationCode(const AnalyserEquationAstPtr &ast, const GeneratorProfilePtr &generatorProfile) { - GeneratorPtr generator = libcellml::Generator::create(); + GeneratorPtr generator = Generator::create(); if (generatorProfile != nullptr) { generator->setProfile(generatorProfile);