diff --git a/src/analyser.cpp b/src/analyser.cpp index 1a5d51c4a..da35840df 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -895,7 +895,7 @@ void Analyser::AnalyserImpl::analyseComponentVariables(const ComponentPtr &compo // different then make sure that they don't both have an initial value. // Alternatively, if the variable held by `internalVariable` has an // initial value which is the name of another variable then make sure - // that it is of constant type. + // that it has the same units. // Note: we always have an initialising variable in the second case. // Indeed, if we were not to have one, it would mean that the // variable is initialised using a reference to a variable that is @@ -923,18 +923,7 @@ void Analyser::AnalyserImpl::analyseComponentVariables(const ComponentPtr &compo auto initialisingVariable = owningComponent(variable)->variable(variable->initialValue()); auto initialisingInternalVariable = Analyser::AnalyserImpl::internalVariable(initialisingVariable); - if (initialisingInternalVariable->mType != AnalyserInternalVariable::Type::INITIALISED) { - auto issue = Issue::IssueImpl::create(); - - issue->mPimpl->setDescription("Variable '" + variable->name() - + "' in component '" + component->name() - + "' 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); - - addIssue(issue); - } else { + if (initialisingInternalVariable->mType == AnalyserInternalVariable::Type::INITIALISED) { auto scalingFactor = Units::scalingFactor(variable->units(), initialisingVariable->units()); if (!areNearlyEqual(scalingFactor, 1.0)) { @@ -945,7 +934,7 @@ void Analyser::AnalyserImpl::analyseComponentVariables(const ComponentPtr &compo + "' 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->setReferenceRule(Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS); issue->mPimpl->mItem->mPimpl->setVariable(variable); addIssue(issue); @@ -2300,9 +2289,13 @@ void Analyser::AnalyserImpl::addInvalidVariableIssue(const AnalyserInternalVaria case AnalyserInternalVariable::Type::SHOULD_BE_STATE: descriptionEnd = "is used in an ODE, but it is not initialised"; + break; + case AnalyserInternalVariable::Type::UNDERCONSTRAINED: + descriptionEnd = "is underconstrained"; + break; default: // AnalyserInternalVariable::Type::OVERCONSTRAINED. - descriptionEnd = "is computed more than once"; + descriptionEnd = "is overconstrained"; break; } @@ -2339,8 +2332,13 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) } // Recursively analyse the model's components' variables. - // Note: we can't do this as part of analyseComponent() since we don't - // necessarily know the state of all the variables. + // Note #1: we can't do this as part of analyseComponent() since we don't + // necessarily know the state of all the variables. + // Note #2: when it comes to variables initialised using another variable, + // we can only do this after all the equations have been analysed, + // i.e. once we know the type of all the variables since a variable + // can be initialised using another variable, but only if it is not + // an algebraic variable. for (size_t i = 0; i < model->componentCount(); ++i) { analyseComponentVariables(model->component(i)); @@ -2502,7 +2500,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) } } - // Detmerine whether some variables have been marked as external. + // Determine whether some variables have been marked as external. auto hasExternalVariables = std::any_of(mInternalVariables.begin(), mInternalVariables.end(), [](const auto &iv) { return iv->mIsExternalVariable; @@ -2577,7 +2575,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) break; case AnalyserInternalVariable::Type::OVERCONSTRAINED: - addInvalidVariableIssue(internalVariable, Issue::ReferenceRule::ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE); + addInvalidVariableIssue(internalVariable, Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED); break; default: // Other types we don't care about. @@ -2612,6 +2610,35 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) return; } + // Make sure that variables that are initialised using another variable are + // not initialised using an algebraic variable. + + for (const auto &internalVariable : mInternalVariables) { + if ((internalVariable->mInitialisingVariable != nullptr) + && !isCellMLReal(internalVariable->mInitialisingVariable->initialValue())) { + auto initialisingInternalVariable = Analyser::AnalyserImpl::internalVariable(owningComponent(internalVariable->mInitialisingVariable)->variable(internalVariable->mInitialisingVariable->initialValue())); + + if (initialisingInternalVariable->mType == AnalyserInternalVariable::Type::ALGEBRAIC_VARIABLE) { + auto issue = Issue::IssueImpl::create(); + + issue->mPimpl->setDescription("Variable '" + internalVariable->mVariable->name() + + "' in component '" + owningComponent(internalVariable->mVariable)->name() + + "' is initialised using variable '" + initialisingInternalVariable->mVariable->name() + + "', which is an algebraic variable. Only a reference to a constant, a computed constant, a state variable, or a non-linear algebraic variable is allowed."); + issue->mPimpl->setReferenceRule(Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE); + issue->mPimpl->mItem->mPimpl->setVariable(internalVariable->mVariable); + + addIssue(issue); + } + } + } + + if (mAnalyser->errorCount() != 0) { + mAnalyserModel->mPimpl->mType = AnalyserModel::Type::INVALID; + + return; + } + // Make sure that our equations are valid. AnalyserInternalVariablePtrs addedExternalVariables; @@ -2713,6 +2740,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // were removed (as a result of some variables in an NLA equation // having been marked as external). + AnalyserInternalVariablePtrs underconstrainedVariables; AnalyserInternalVariablePtrs overconstrainedVariables; for (const auto &internalEquation : mInternalEquations) { @@ -2739,16 +2767,28 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) } } break; case AnalyserInternalEquation::Type::NLA: - if (internalEquation->mNlaSiblings.size() + 1 > internalEquation->mUnknownVariables.size()) { - // There are more NLA equations than unknown variables, so all - // the unknown variables involved in the NLA system should be - // considered as overconstrained. + if (internalEquation->mNlaSiblings.size() + 1 < internalEquation->mUnknownVariables.size()) { + // There are fewer NLA equations than unknown variables, so all the unknown variables involved in the + // NLA system should be considered as underconstrained. + + for (const auto &unknownVariable : internalEquation->mUnknownVariables) { + if (std::find(underconstrainedVariables.begin(), underconstrainedVariables.end(), unknownVariable) == underconstrainedVariables.end()) { + unknownVariable->mType = AnalyserInternalVariable::Type::UNDERCONSTRAINED; + + addInvalidVariableIssue(unknownVariable, Issue::ReferenceRule::ANALYSER_VARIABLE_UNDERCONSTRAINED); + + underconstrainedVariables.push_back(unknownVariable); + } + } + } else if (internalEquation->mNlaSiblings.size() + 1 > internalEquation->mUnknownVariables.size()) { + // There are more NLA equations than unknown variables, so all the unknown variables involved in the NLA + // system should be considered as overconstrained. for (const auto &unknownVariable : internalEquation->mUnknownVariables) { if (std::find(overconstrainedVariables.begin(), overconstrainedVariables.end(), unknownVariable) == overconstrainedVariables.end()) { unknownVariable->mType = AnalyserInternalVariable::Type::OVERCONSTRAINED; - addInvalidVariableIssue(unknownVariable, Issue::ReferenceRule::ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE); + addInvalidVariableIssue(unknownVariable, Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED); overconstrainedVariables.push_back(unknownVariable); } @@ -2762,7 +2802,15 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) } if (mAnalyser->errorCount() != 0) { - mAnalyserModel->mPimpl->mType = AnalyserModel::Type::OVERCONSTRAINED; + if (!underconstrainedVariables.empty()) { + if (!overconstrainedVariables.empty()) { + mAnalyserModel->mPimpl->mType = AnalyserModel::Type::UNSUITABLY_CONSTRAINED; + } else { + mAnalyserModel->mPimpl->mType = AnalyserModel::Type::UNDERCONSTRAINED; + } + } else { + mAnalyserModel->mPimpl->mType = AnalyserModel::Type::OVERCONSTRAINED; + } return; } diff --git a/src/analyser_p.h b/src/analyser_p.h index 302bf97cd..da773b43b 100644 --- a/src/analyser_p.h +++ b/src/analyser_p.h @@ -51,6 +51,7 @@ struct AnalyserInternalVariable COMPUTED_VARIABLE_BASED_CONSTANT, INITIALISED_ALGEBRAIC_VARIABLE, ALGEBRAIC_VARIABLE, + UNDERCONSTRAINED, OVERCONSTRAINED }; diff --git a/src/api/libcellml/generatorprofile.h b/src/api/libcellml/generatorprofile.h index 623984536..9d40971f8 100644 --- a/src/api/libcellml/generatorprofile.h +++ b/src/api/libcellml/generatorprofile.h @@ -3771,10 +3771,13 @@ class LIBCELLML_EXPORT GeneratorProfile * Return the @c std::string for the interface to compute computed * constants. * + * @param forDifferentialModel Whether the interface to compute computed + * constants is for a differential model, as opposed to an algebraic model. + * * @return The @c std::string for the interface to compute computed * constants. */ - std::string interfaceComputeComputedConstantsMethodString() const; + std::string interfaceComputeComputedConstantsMethodString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the interface to compute computed @@ -3782,10 +3785,13 @@ class LIBCELLML_EXPORT GeneratorProfile * * Set the @c std::string for the interface to compute computed constants. * + * @param forDifferentialModel Whether the interface to compute computed + * constants is for a differential model, as opposed to an algebraic model. * @param interfaceComputeComputedConstantsMethodString The @c std::string * to use for the interface to compute computed constants. */ - void setInterfaceComputeComputedConstantsMethodString(const std::string &interfaceComputeComputedConstantsMethodString); + void setInterfaceComputeComputedConstantsMethodString(bool forDifferentialModel, + const std::string &interfaceComputeComputedConstantsMethodString); /** * @brief Get the @c std::string for the implementation to compute computed @@ -3794,10 +3800,13 @@ class LIBCELLML_EXPORT GeneratorProfile * Return the @c std::string for the implementation to compute computed * constants. * + * @param forDifferentialModel Whether the implementation to compute computed + * constants is for a differential model, as opposed to an algebraic model. + * * @return The @c std::string for the implementation to compute computed * constants. */ - std::string implementationComputeComputedConstantsMethodString() const; + std::string implementationComputeComputedConstantsMethodString(bool forDifferentialModel) const; /** * @brief Set the @c std::string for the implementation to compute computed @@ -3807,11 +3816,14 @@ class LIBCELLML_EXPORT GeneratorProfile * constants. To be useful, the string should contain the [CODE] tag, which * will be replaced with some code to compute computed constants. * + * @param forDifferentialModel Whether the implementation to compute computed + * constants is for a differential model, as opposed to an algebraic model. * @param implementationComputeComputedConstantsMethodString The * @c std::string to use for the implementation to compute computed * constants. */ - void setImplementationComputeComputedConstantsMethodString(const std::string &implementationComputeComputedConstantsMethodString); + void setImplementationComputeComputedConstantsMethodString(bool forDifferentialModel, + const std::string &implementationComputeComputedConstantsMethodString); /** * @brief Get the @c std::string for the interface to compute rates. diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index fcd1c202e..e4882e812 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -192,14 +192,16 @@ class LIBCELLML_EXPORT Issue ANALYSER_UNITS, ANALYSER_UNLINKED_UNITS, ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE, - ANALYSER_VARIABLE_NON_CONSTANT_INITIALISATION, + ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE, + ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS, ANALYSER_VOI_INITIALISED, ANALYSER_VOI_SEVERAL, ANALYSER_ODE_NOT_FIRST_ORDER, ANALYSER_VARIABLE_UNUSED, ANALYSER_STATE_NOT_INITIALISED, ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE, - ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE, + ANALYSER_VARIABLE_UNDERCONSTRAINED, + ANALYSER_VARIABLE_OVERCONSTRAINED, ANALYSER_EXTERNAL_VARIABLE_DIFFERENT_MODEL, ANALYSER_EXTERNAL_VARIABLE_VOI, ANALYSER_EXTERNAL_VARIABLE_USE_PRIMARY_VARIABLE, diff --git a/src/bindings/javascript/issue.cpp b/src/bindings/javascript/issue.cpp index e1422221c..b21279ee3 100644 --- a/src/bindings/javascript/issue.cpp +++ b/src/bindings/javascript/issue.cpp @@ -39,9 +39,11 @@ EMSCRIPTEN_BINDINGS(libcellml_issue) { .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) + .value("ANALYSER_VARIABLE_UNDERCONSTRAINED", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNDERCONSTRAINED) + .value("ANALYSER_VARIABLE_OVERCONSTRAINED", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED) .value("ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE) - .value("ANALYSER_VARIABLE_NON_CONSTANT_INITIALISATION", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_NON_CONSTANT_INITIALISATION) + .value("ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE) + .value("ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS) .value("ANALYSER_VARIABLE_UNUSED", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNUSED) .value("ANALYSER_VOI_INITIALISED", libcellml::Issue::ReferenceRule::ANALYSER_VOI_INITIALISED) .value("ANALYSER_VOI_SEVERAL", libcellml::Issue::ReferenceRule::ANALYSER_VOI_SEVERAL) diff --git a/src/bindings/python/__init__.py b/src/bindings/python/__init__.py index 32f683a11..b0f9a0f83 100644 --- a/src/bindings/python/__init__.py +++ b/src/bindings/python/__init__.py @@ -310,14 +310,16 @@ class Object: 'ANALYSER_UNITS', 'ANALYSER_UNLINKED_UNITS', 'ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE', - 'ANALYSER_VARIABLE_NON_CONSTANT_INITIALISATION', + 'ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE', + 'ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS', 'ANALYSER_VOI_INITIALISED', 'ANALYSER_VOI_SEVERAL', 'ANALYSER_ODE_NOT_FIRST_ORDER', 'ANALYSER_VARIABLE_UNUSED', 'ANALYSER_STATE_NOT_INITIALISED', 'ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE', - 'ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE', + 'ANALYSER_VARIABLE_UNDERCONSTRAINED', + 'ANALYSER_VARIABLE_OVERCONSTRAINED', 'ANALYSER_EXTERNAL_VARIABLE_DIFFERENT_MODEL', 'ANALYSER_EXTERNAL_VARIABLE_VOI', 'ANALYSER_EXTERNAL_VARIABLE_USE_PRIMARY_VARIABLE', diff --git a/src/generator.cpp b/src/generator.cpp index 84d5ec015..f58c676e5 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1246,17 +1246,36 @@ std::string generateDoubleCode(const std::string &value) return value.substr(0, ePos) + ".0" + value.substr(ePos); } -std::string Generator::GeneratorImpl::generateDoubleOrConstantVariableNameCode(const AnalyserModelPtr &analyserModel, - const VariablePtr &variable) +std::string Generator::GeneratorImpl::generateDoubleOrVariableNameCode(const AnalyserModelPtr &analyserModel, const VariablePtr &variable) { if (isCellMLReal(variable->initialValue())) { return generateDoubleCode(variable->initialValue()); } auto initialValueVariable = owningComponent(variable)->variable(variable->initialValue()); - auto analyserInitialValueVariable = analyserModel->analyserVariable(initialValueVariable); + auto initialValueAnalyserVariable = analyserModel->analyserVariable(initialValueVariable); + std::string arrayName; + + switch (initialValueAnalyserVariable->type()) { + case AnalyserVariable::Type::STATE: + arrayName = mProfile->statesArrayString(); + + break; + case AnalyserVariable::Type::CONSTANT: + arrayName = mProfile->constantsArrayString(); + + break; + case AnalyserVariable::Type::COMPUTED_CONSTANT: + arrayName = mProfile->computedConstantsArrayString(); + + break; + default: // If it is not one of the above types then it has to be an algebraic variable. + arrayName = mProfile->algebraicVariablesArrayString(); + + break; + } - return mProfile->constantsArrayString() + mProfile->openArrayString() + analyserVariableIndexString(analyserModel, analyserInitialValueVariable) + mProfile->closeArrayString(); + return arrayName + mProfile->openArrayString() + analyserVariableIndexString(analyserModel, initialValueAnalyserVariable) + mProfile->closeArrayString(); } std::string Generator::GeneratorImpl::generateVariableNameCode(const AnalyserModelPtr &analyserModel, @@ -2097,7 +2116,7 @@ std::string Generator::GeneratorImpl::generateInitialisationCode(const AnalyserM auto code = generateVariableNameCode(analyserModel, analyserVariable->variable()) + mProfile->equalityString() - + scalingFactorCode + generateDoubleOrConstantVariableNameCode(analyserModel, initialisingVariable) + + scalingFactorCode + generateDoubleOrVariableNameCode(analyserModel, initialisingVariable) + mProfile->commandSeparatorString() + "\n"; if (isTrackedVariable(analyserModel, analyserVariable, false)) { @@ -2209,6 +2228,99 @@ std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserModelPt generatedConstantDependencies, true); } +bool Generator::GeneratorImpl::hasComputedConstantDependency(const AnalyserModelPtr &analyserModel, + const AnalyserVariablePtr &analyserVariable) +{ + // Check if the analyser variable has a direct or indirect dependency on a computed constant. + + if (analyserVariable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) { + return true; + } + + auto initialisingVariable = analyserVariable->initialisingVariable(); + auto initialValueVariable = owningComponent(initialisingVariable)->variable(initialisingVariable->initialValue()); + + if (initialValueVariable == nullptr) { + return false; + } + + return hasComputedConstantDependency(analyserModel, analyserModel->analyserVariable(initialValueVariable)); +} + +std::string Generator::GeneratorImpl::generateInitialiseVariableCode(const AnalyserModelPtr &analyserModel, + const AnalyserVariablePtr &analyserVariable, + std::vector &remainingAnalyserEquations, + std::vector &remainingStates, + std::vector &remainingConstants, + std::vector &remainingComputedConstants, + std::vector &remainingAlgebraic, + std::vector *generatedConstantDependencies) +{ + std::string res; + + // Check if the analyser variable is initialised using a constant value or an initialising variable. + + auto initialisingVariable = analyserVariable->initialisingVariable(); + auto initialValueVariable = (initialisingVariable != nullptr) ? owningComponent(initialisingVariable)->variable(initialisingVariable->initialValue()) : nullptr; + auto initialiseAnalyserVariable = true; + + if (initialValueVariable != nullptr) { + // The initial value references a state, a constant, a computed constant, or an algebraic variable, so generate + // initialisation code for that variable first, if conditions are met. + + auto initialValueAnalyserVariable = analyserModel->analyserVariable(initialValueVariable); + auto &remainingVariables = (initialValueAnalyserVariable->type() == AnalyserVariable::Type::STATE) ? + remainingStates : + (initialValueAnalyserVariable->type() == AnalyserVariable::Type::CONSTANT) ? + remainingConstants : + (initialValueAnalyserVariable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) ? + remainingComputedConstants : + remainingAlgebraic; + + if (((generatedConstantDependencies == nullptr) && !hasComputedConstantDependency(analyserModel, initialValueAnalyserVariable)) + || (generatedConstantDependencies != nullptr)) { + auto initialisingAnalyserVariable = std::find_if(remainingVariables.begin(), remainingVariables.end(), + [&](const AnalyserVariablePtr &av) { + return areEquivalentVariables(initialValueVariable, av->variable()); + }); + + if (initialisingAnalyserVariable != remainingVariables.end()) { + res += generateInitialiseVariableCode(analyserModel, AnalyserVariablePtr(*initialisingAnalyserVariable), + remainingAnalyserEquations, remainingStates, remainingConstants, + remainingComputedConstants, remainingAlgebraic, + generatedConstantDependencies); + } + } else { + initialiseAnalyserVariable = false; + } + } + + // Now initialise the analyser variable itself, if we can. + + if (initialiseAnalyserVariable) { + auto &remainingVariables = (analyserVariable->type() == AnalyserVariable::Type::STATE) ? + remainingStates : + (analyserVariable->type() == AnalyserVariable::Type::CONSTANT) ? + remainingConstants : + (analyserVariable->type() == AnalyserVariable::Type::COMPUTED_CONSTANT) ? + remainingComputedConstants : + remainingAlgebraic; + auto remainingVariable = std::find(remainingVariables.begin(), remainingVariables.end(), analyserVariable); + + if (remainingVariable != remainingVariables.end()) { + if (remainingVariables != remainingComputedConstants) { + res += generateInitialisationCode(analyserModel, AnalyserVariablePtr(*remainingVariable)); + } else { + res += generateEquationCode(analyserModel, analyserVariable->analyserEquation(0), remainingAnalyserEquations, *generatedConstantDependencies); + } + + remainingVariables.erase(remainingVariable); + } + } + + return res; +} + void Generator::GeneratorImpl::addInterfaceComputeModelMethodsCode(const AnalyserModelPtr &analyserModel) { auto interfaceInitialiseArraysMethodString = mProfile->interfaceInitialiseArraysMethodString(modelHasOdes(analyserModel)); @@ -2218,8 +2330,8 @@ void Generator::GeneratorImpl::addInterfaceComputeModelMethodsCode(const Analyse code += interfaceInitialiseArraysMethodString; } - if (!mProfile->interfaceComputeComputedConstantsMethodString().empty()) { - code += mProfile->interfaceComputeComputedConstantsMethodString(); + if (!mProfile->interfaceComputeComputedConstantsMethodString(modelHasOdes(analyserModel)).empty()) { + code += mProfile->interfaceComputeComputedConstantsMethodString(modelHasOdes(analyserModel)); } auto interfaceComputeRatesMethodString = mProfile->interfaceComputeRatesMethodString(analyserModel->hasExternalVariables()); @@ -2242,103 +2354,76 @@ void Generator::GeneratorImpl::addInterfaceComputeModelMethodsCode(const Analyse } } -std::string Generator::GeneratorImpl::generateConstantInitialisationCode(const AnalyserModelPtr &analyserModel, - 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(analyserModel, crtConstant, remainingConstants); - } - } - - auto code = generateInitialisationCode(analyserModel, *constant); - - remainingConstants.erase(constant); - - return code; -} - void Generator::GeneratorImpl::addImplementationInitialiseArraysMethodCode(const AnalyserModelPtr &analyserModel, - std::vector &remainingAnalyserEquations) + std::vector &remainingAnalyserEquations, + std::vector &remainingStates, + std::vector &remainingConstants, + std::vector &remainingComputedConstants, + std::vector &remainingAlgebraic) { - auto implementationInitialiseArraysMethodString = mProfile->implementationInitialiseArraysMethodString(modelHasOdes(analyserModel)); - - if (!implementationInitialiseArraysMethodString.empty()) { - // Initialise our states (after, if needed, initialising the constant on which it depends). + // Note: we must always generate the method body (even if we don't end up generating the method itself) because + // addImplementationComputeComputedConstantsMethodCode() expects our "remaining" parameters to be updated + // correctly. - std::string methodBody; - auto constants = analyserModel->constants(); - - for (const auto &state : analyserModel->states()) { - auto initialisingVariable = state->initialisingVariable(); - auto initialValue = initialisingVariable->initialValue(); + // Initialise our states. - if (!isCellMLReal(initialValue)) { - // The initial value references a constant. + std::string methodBody; - auto initialisingComponent = owningComponent(initialisingVariable); - auto constant = std::find_if(constants.begin(), constants.end(), - [=](const AnalyserVariablePtr &av) -> bool { - return initialisingComponent->variable(initialValue)->hasEquivalentVariable(av->variable()); - }); + for (const auto &state : analyserModel->states()) { + methodBody += generateInitialiseVariableCode(analyserModel, state, + remainingAnalyserEquations, remainingStates, remainingConstants, + remainingComputedConstants, remainingAlgebraic); + } - methodBody += generateConstantInitialisationCode(analyserModel, constant, constants); - } + // Use an initial guess of zero for rates computed using an NLA system (see the note below). - methodBody += generateInitialisationCode(analyserModel, state); + for (const auto &state : analyserModel->states()) { + if (state->analyserEquation(0)->type() == AnalyserEquation::Type::NLA) { + methodBody += generateZeroInitialisationCode(analyserModel, state); } + } - // Use an initial guess of zero for rates computed using an NLA system - // (see the note below). + // Initialise our remaining constants. - for (const auto &state : analyserModel->states()) { - if (state->analyserEquation(0)->type() == AnalyserEquation::Type::NLA) { - methodBody += generateZeroInitialisationCode(analyserModel, state); - } - } + while (!remainingConstants.empty()) { + methodBody += generateInitialiseVariableCode(analyserModel, AnalyserVariablePtr(*remainingConstants.begin()), + remainingAnalyserEquations, remainingStates, remainingConstants, + remainingComputedConstants, remainingAlgebraic); + } - // Initialise our (remaining) constants. + // Initialise our computed constants that are initialised using an equation (e.g., x = 3 rather than x with an + // initial value of 3). - while (!constants.empty()) { - methodBody += generateConstantInitialisationCode(analyserModel, constants.begin(), constants); - } + std::vector generatedConstantDependencies; - // Initialise our computed constants that are initialised using an equation (e.g., x = 3 rather than x with an - // initial value of 3). + for (const auto &equation : analyserModel->analyserEquations()) { + if (equation->type() == AnalyserEquation::Type::CONSTANT) { + methodBody += generateEquationCode(analyserModel, equation, remainingAnalyserEquations, generatedConstantDependencies); + } + } - std::vector generatedConstantDependencies; + // 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 &analyserEquation : analyserModel->analyserEquations()) { - if (analyserEquation->type() == AnalyserEquation::Type::CONSTANT) { - methodBody += generateEquationCode(analyserModel, analyserEquation, remainingAnalyserEquations, generatedConstantDependencies); - } + for (const auto &algebraicVariable : analyserModel->algebraicVariables()) { + if (algebraicVariable->initialisingVariable() != nullptr) { + methodBody += generateInitialiseVariableCode(analyserModel, algebraicVariable, + remainingAnalyserEquations, remainingStates, remainingConstants, + remainingComputedConstants, remainingAlgebraic); + } else if (algebraicVariable->analyserEquation(0)->type() == AnalyserEquation::Type::NLA) { + methodBody += generateZeroInitialisationCode(analyserModel, algebraicVariable); } + } - // 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. + // Generate the method itself, if needed. - for (const auto &algebraicVariable : analyserModel->algebraicVariables()) { - if (algebraicVariable->initialisingVariable() != nullptr) { - methodBody += generateInitialisationCode(analyserModel, algebraicVariable); - } else if (algebraicVariable->analyserEquation(0)->type() == AnalyserEquation::Type::NLA) { - methodBody += generateZeroInitialisationCode(analyserModel, algebraicVariable); - } - } + auto implementationInitialiseArraysMethodString = mProfile->implementationInitialiseArraysMethodString(modelHasOdes(analyserModel)); + if (!implementationInitialiseArraysMethodString.empty()) { mCode += newLineIfNeeded() + replace(implementationInitialiseArraysMethodString, "[CODE]", generateMethodBodyCode(methodBody)); @@ -2346,21 +2431,50 @@ void Generator::GeneratorImpl::addImplementationInitialiseArraysMethodCode(const } void Generator::GeneratorImpl::addImplementationComputeComputedConstantsMethodCode(const AnalyserModelPtr &analyserModel, - std::vector &remainingAnalyserEquations) + std::vector &remainingAnalyserEquations, + std::vector &remainingStates, + std::vector &remainingConstants, + std::vector &remainingComputedConstants, + std::vector &remainingAlgebraic) { - if (!mProfile->implementationComputeComputedConstantsMethodString().empty()) { + if (!mProfile->implementationComputeComputedConstantsMethodString(modelHasOdes(analyserModel)).empty()) { + // Initialise our remaining states (which are initialised using a computed constant). + std::string methodBody; std::vector generatedConstantDependencies; + for (const auto &state : analyserModel->states()) { + methodBody += generateInitialiseVariableCode(analyserModel, state, + remainingAnalyserEquations, remainingStates, remainingConstants, + remainingComputedConstants, remainingAlgebraic, + &generatedConstantDependencies); + } + + // Initialise our remaining computed constants. + for (const auto &analyserEquation : analyserModel->analyserEquations()) { if ((analyserEquation->type() == AnalyserEquation::Type::COMPUTED_CONSTANT) && isTrackedEquation(analyserEquation, true)) { - methodBody += generateEquationCode(analyserModel, analyserEquation, remainingAnalyserEquations, generatedConstantDependencies); + methodBody += generateInitialiseVariableCode(analyserModel, analyserEquation->computedConstant(0), + remainingAnalyserEquations, remainingStates, remainingConstants, + remainingComputedConstants, remainingAlgebraic, + &generatedConstantDependencies); + } + } + + // Initialise our algebraic variables that are initialised using a computed constant. + + for (const auto &algebraicVariable : analyserModel->algebraicVariables()) { + if (algebraicVariable->initialisingVariable() != nullptr) { + methodBody += generateInitialiseVariableCode(analyserModel, algebraicVariable, + remainingAnalyserEquations, remainingStates, remainingConstants, + remainingComputedConstants, remainingAlgebraic, + &generatedConstantDependencies); } } mCode += newLineIfNeeded() - + replace(mProfile->implementationComputeComputedConstantsMethodString(), + + replace(mProfile->implementationComputeComputedConstantsMethodString(modelHasOdes(analyserModel)), "[CODE]", generateMethodBodyCode(methodBody)); } } @@ -2405,7 +2519,7 @@ void Generator::GeneratorImpl::addImplementationComputeVariablesMethodCode(const if (!implementationComputeVariablesMethodString.empty()) { std::string methodBody; auto analyserEquations = analyserModel->analyserEquations(); - std::vector newRemainingAnalyserEquations {std::begin(analyserEquations), std::end(analyserEquations)}; + auto newRemainingAnalyserEquations = analyserEquations; std::vector generatedConstantDependencies; for (const auto &analyserEquation : analyserEquations) { @@ -2683,14 +2797,21 @@ std::string Generator::implementationCode(const AnalyserModelPtr &analyserModel) // Add code for the implementation to initialise our arrays. - auto equations = analyserModel->analyserEquations(); - std::vector remainingAnalyserEquations {std::begin(equations), std::end(equations)}; + auto remainingAnalyserEquations = analyserModel->analyserEquations(); + auto remainingStates = analyserModel->states(); + auto remainingConstants = analyserModel->constants(); + auto remainingComputedConstants = analyserModel->computedConstants(); + auto remainingAlgebraic = analyserModel->algebraicVariables(); - pFunc()->addImplementationInitialiseArraysMethodCode(analyserModel, remainingAnalyserEquations); + pFunc()->addImplementationInitialiseArraysMethodCode(analyserModel, remainingAnalyserEquations, remainingStates, + remainingConstants, remainingComputedConstants, + remainingAlgebraic); // Add code for the implementation to compute our computed constants. - pFunc()->addImplementationComputeComputedConstantsMethodCode(analyserModel, remainingAnalyserEquations); + pFunc()->addImplementationComputeComputedConstantsMethodCode(analyserModel, remainingAnalyserEquations, remainingStates, + remainingConstants, remainingComputedConstants, + remainingAlgebraic); // Add code for the implementation to compute our rates (and any variables // on which they depend). diff --git a/src/generator_p.h b/src/generator_p.h index 88313a323..ca5102354 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -147,8 +147,7 @@ struct Generator::GeneratorImpl: public Logger::LoggerImpl std::string generateMethodBodyCode(const std::string &methodBody) const; - std::string generateDoubleOrConstantVariableNameCode(const AnalyserModelPtr &analyserModel, - const VariablePtr &variable); + std::string generateDoubleOrVariableNameCode(const AnalyserModelPtr &analyserModel, const VariablePtr &variable); std::string generateVariableNameCode(const AnalyserModelPtr &analyserModel, const VariablePtr &variable, bool state = true); @@ -188,19 +187,34 @@ struct Generator::GeneratorImpl: public Logger::LoggerImpl std::string generateEquationCode(const AnalyserModelPtr &analyserModel, const AnalyserEquationPtr &analyserEquation, std::vector &remainingAnalyserEquations, std::vector &generatedConstantDependencies); + bool hasComputedConstantDependency(const AnalyserModelPtr &analyserModel, + const AnalyserVariablePtr &analyserVariable); + std::string generateInitialiseVariableCode(const AnalyserModelPtr &analyserModel, + const AnalyserVariablePtr &analyserVariable, + std::vector &remainingAnalyserEquations, + std::vector &remainingStates, + std::vector &remainingConstants, + std::vector &remainingComputedConstants, + std::vector &remainingAlgebraic, + std::vector *generatedConstantDependencies = nullptr); void addInterfaceComputeModelMethodsCode(const AnalyserModelPtr &analyserModel); - std::string generateConstantInitialisationCode(const AnalyserModelPtr &analyserModel, - const std::vector::iterator constant, - std::vector &remainingConstants); void addImplementationInitialiseArraysMethodCode(const AnalyserModelPtr &analyserModel, - std::vector &remainingAnalyserEquations); + std::vector &remainingEquations, + std::vector &remainingStates, + std::vector &remainingConstants, + std::vector &remainingComputedConstants, + std::vector &remainingAlgebraic); void addImplementationComputeComputedConstantsMethodCode(const AnalyserModelPtr &analyserModel, - std::vector &remainingAnalyserEquations); + std::vector &remainingEquations, + std::vector &remainingStates, + std::vector &remainingConstants, + std::vector &remainingComputedConstants, + std::vector &remainingAlgebraic); void addImplementationComputeRatesMethodCode(const AnalyserModelPtr &analyserModel, - std::vector &remainingAnalyserEquations); + std::vector &remainingEquations); void addImplementationComputeVariablesMethodCode(const AnalyserModelPtr &analyserModel, - std::vector &remainingAnalyserEquations); + std::vector &remainingEquations); }; } // namespace libcellml diff --git a/src/generatorprofile.cpp b/src/generatorprofile.cpp index 07ae559b0..961aa1499 100644 --- a/src/generatorprofile.cpp +++ b/src/generatorprofile.cpp @@ -225,7 +225,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "#include \n"; mInterfaceVersionString = "extern const char VERSION[];\n"; - mImplementationVersionString = "const char VERSION[] = \"0.6.0\";\n"; + mImplementationVersionString = "const char VERSION[] = \"0.7.0\";\n"; mInterfaceLibcellmlVersionString = "extern const char LIBCELLML_VERSION[];\n"; mImplementationLibcellmlVersionString = "const char LIBCELLML_VERSION[] = \"[LIBCELLML_VERSION]\";\n"; @@ -489,11 +489,17 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "[CODE]" "}\n"; - mInterfaceComputeComputedConstantsMethodString = "void computeComputedConstants(double *constants, double *computedConstants);\n"; - mImplementationComputeComputedConstantsMethodString = "void computeComputedConstants(double *constants, double *computedConstants)\n" - "{\n" - "[CODE]" - "}\n"; + mInterfaceComputeComputedConstantsMethodFamString = "void computeComputedConstants(double *constants, double *computedConstants, double *algebraic);\n"; + mImplementationComputeComputedConstantsMethodFamString = "void computeComputedConstants(double *constants, double *computedConstants, double *algebraic)\n" + "{\n" + "[CODE]" + "}\n"; + + mInterfaceComputeComputedConstantsMethodFdmString = "void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n"; + mImplementationComputeComputedConstantsMethodFdmString = "void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + "{\n" + "[CODE]" + "}\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" @@ -735,7 +741,7 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "\n"; mInterfaceVersionString = ""; - mImplementationVersionString = "__version__ = \"0.5.0\"\n"; + mImplementationVersionString = "__version__ = \"0.6.0\"\n"; mInterfaceLibcellmlVersionString = ""; mImplementationLibcellmlVersionString = "LIBCELLML_VERSION = \"[LIBCELLML_VERSION]\"\n"; @@ -920,10 +926,15 @@ void GeneratorProfile::GeneratorProfileImpl::loadProfile(GeneratorProfile::Profi "def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables):\n" "[CODE]"; - mInterfaceComputeComputedConstantsMethodString = ""; - mImplementationComputeComputedConstantsMethodString = "\n" - "def compute_computed_constants(constants, computed_constants):\n" - "[CODE]"; + mInterfaceComputeComputedConstantsMethodFamString = ""; + mImplementationComputeComputedConstantsMethodFamString = "\n" + "def compute_computed_constants(constants, computed_constants, algebraic):\n" + "[CODE]"; + + mInterfaceComputeComputedConstantsMethodFdmString = ""; + mImplementationComputeComputedConstantsMethodFdmString = "\n" + "def compute_computed_constants(states, rates, constants, computed_constants, algebraic):\n" + "[CODE]"; mInterfaceComputeRatesMethodWoevString = ""; mImplementationComputeRatesMethodWoevString = "\n" @@ -2796,24 +2807,42 @@ void GeneratorProfile::setImplementationInitialiseArraysMethodString(bool forDif } } -std::string GeneratorProfile::interfaceComputeComputedConstantsMethodString() const +std::string GeneratorProfile::interfaceComputeComputedConstantsMethodString(bool forDifferentialModel) const { - return mPimpl->mInterfaceComputeComputedConstantsMethodString; + if (forDifferentialModel) { + return mPimpl->mInterfaceComputeComputedConstantsMethodFdmString; + } + + return mPimpl->mInterfaceComputeComputedConstantsMethodFamString; } -void GeneratorProfile::setInterfaceComputeComputedConstantsMethodString(const std::string &interfaceComputeComputedConstantsMethodString) +void GeneratorProfile::setInterfaceComputeComputedConstantsMethodString(bool forDifferentialModel, + const std::string &interfaceComputeComputedConstantsMethodString) { - mPimpl->mInterfaceComputeComputedConstantsMethodString = interfaceComputeComputedConstantsMethodString; + if (forDifferentialModel) { + mPimpl->mInterfaceComputeComputedConstantsMethodFdmString = interfaceComputeComputedConstantsMethodString; + } else { + mPimpl->mInterfaceComputeComputedConstantsMethodFamString = interfaceComputeComputedConstantsMethodString; + } } -std::string GeneratorProfile::implementationComputeComputedConstantsMethodString() const +std::string GeneratorProfile::implementationComputeComputedConstantsMethodString(bool forDifferentialModel) const { - return mPimpl->mImplementationComputeComputedConstantsMethodString; + if (forDifferentialModel) { + return mPimpl->mImplementationComputeComputedConstantsMethodFdmString; + } + + return mPimpl->mImplementationComputeComputedConstantsMethodFamString; } -void GeneratorProfile::setImplementationComputeComputedConstantsMethodString(const std::string &implementationComputeComputedConstantsMethodString) +void GeneratorProfile::setImplementationComputeComputedConstantsMethodString(bool forDifferentialModel, + const std::string &implementationComputeComputedConstantsMethodString) { - mPimpl->mImplementationComputeComputedConstantsMethodString = implementationComputeComputedConstantsMethodString; + if (forDifferentialModel) { + mPimpl->mImplementationComputeComputedConstantsMethodFdmString = implementationComputeComputedConstantsMethodString; + } else { + mPimpl->mImplementationComputeComputedConstantsMethodFamString = implementationComputeComputedConstantsMethodString; + } } std::string GeneratorProfile::interfaceComputeRatesMethodString(bool withExternalVariables) const diff --git a/src/generatorprofile_p.h b/src/generatorprofile_p.h index b4192661b..9bc965d86 100644 --- a/src/generatorprofile_p.h +++ b/src/generatorprofile_p.h @@ -279,8 +279,11 @@ struct GeneratorProfile::GeneratorProfileImpl std::string mInterfaceInitialiseArraysMethodFdmString; std::string mImplementationInitialiseArraysMethodFdmString; - std::string mInterfaceComputeComputedConstantsMethodString; - std::string mImplementationComputeComputedConstantsMethodString; + std::string mInterfaceComputeComputedConstantsMethodFamString; + std::string mImplementationComputeComputedConstantsMethodFamString; + + std::string mInterfaceComputeComputedConstantsMethodFdmString; + std::string mImplementationComputeComputedConstantsMethodFdmString; std::string mInterfaceComputeRatesMethodWoevString; std::string mImplementationComputeRatesMethodWoevString; diff --git a/src/generatorprofilesha1values.h b/src/generatorprofilesha1values.h index 9f8fa7640..c21e4fcfe 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[] = "ff9da09dff282a8fe3bc53bcd9f0946245adf3ee"; -static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "ad80df6979562585a826b01671b17f81b422af10"; +static const char C_GENERATOR_PROFILE_SHA1[] = "24b7a2f82510d2f79aeaee509a1b1b04ea1d749b"; +static const char PYTHON_GENERATOR_PROFILE_SHA1[] = "b117a2500aae147f477127f0bfb0e2c9e242c6c8"; } // namespace libcellml diff --git a/src/generatorprofiletools.cpp b/src/generatorprofiletools.cpp index 98b94e742..f1efeef80 100644 --- a/src/generatorprofiletools.cpp +++ b/src/generatorprofiletools.cpp @@ -539,8 +539,11 @@ std::string generatorProfileAsString(const GeneratorProfilePtr &generatorProfile profileContents += generatorProfile->interfaceInitialiseArraysMethodString(true) + generatorProfile->implementationInitialiseArraysMethodString(true); - profileContents += generatorProfile->interfaceComputeComputedConstantsMethodString() - + generatorProfile->implementationComputeComputedConstantsMethodString(); + profileContents += generatorProfile->interfaceComputeComputedConstantsMethodString(false) + + generatorProfile->implementationComputeComputedConstantsMethodString(false); + + profileContents += generatorProfile->interfaceComputeComputedConstantsMethodString(true) + + generatorProfile->implementationComputeComputedConstantsMethodString(true); profileContents += generatorProfile->interfaceComputeRatesMethodString(false) + generatorProfile->implementationComputeRatesMethodString(false); diff --git a/src/issue.cpp b/src/issue.cpp index 38086af46..da64bd978 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -202,14 +202,16 @@ static const std::map> ruleToInfo {Issue::ReferenceRule::ANALYSER_UNITS, {"ANALYSER_UNITS", "", docsUrl, ""}}, {Issue::ReferenceRule::ANALYSER_UNLINKED_UNITS, {"ANALYSER_UNLINKED_UNITS", "", docsUrl, ""}}, {Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE, {"ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE", "", docsUrl, ""}}, - {Issue::ReferenceRule::ANALYSER_VARIABLE_NON_CONSTANT_INITIALISATION, {"ANALYSER_VARIABLE_NON_CONSTANT_INITIALISATION", "", docsUrl, ""}}, + {Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE, {"ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE", "", docsUrl, ""}}, + {Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS, {"ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS", "", docsUrl, ""}}, {Issue::ReferenceRule::ANALYSER_VOI_INITIALISED, {"ANALYSER_VOI_INITIALISED", "", docsUrl, ""}}, {Issue::ReferenceRule::ANALYSER_VOI_SEVERAL, {"ANALYSER_VOI_SEVERAL", "", docsUrl, ""}}, {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_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_VARIABLE_UNDERCONSTRAINED, {"ANALYSER_VARIABLE_UNDERCONSTRAINED", "", docsUrl, ""}}, + {Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED, {"ANALYSER_VARIABLE_OVERCONSTRAINED", "", 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, ""}}, {Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_USE_PRIMARY_VARIABLE, {"ANALYSER_EXTERNAL_VARIABLE_USE_PRIMARY_VARIABLE", "", docsUrl, ""}}, diff --git a/tests/analyser/analyser.cpp b/tests/analyser/analyser.cpp index c1532bdac..421a226a9 100644 --- a/tests/analyser/analyser.cpp +++ b/tests/analyser/analyser.cpp @@ -237,15 +237,15 @@ TEST(Analyser, variableInitialisedTwice) EXPECT_EQ(libcellml::AnalyserModel::Type::INVALID, analyser->analyserModel()->type()); } -TEST(Analyser, nonConstantInitialisingVariable) +TEST(Analyser, variableInitialisedUsingANonExistingVariable) { auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents("analyser/non_constant_initialising_variable.cellml")); + auto model = parser->parseModel(fileContents("analyser/variable_initialised_using_a_non_existing_variable.cellml")); EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "Variable 'x' in component 'main' is initialised using variable 'k2', which is not a constant.", + "Variable 'x' in component 'main' has an invalid initial value 'k'. Initial values must be a real number string or a variable reference.", }; auto analyser = libcellml::Analyser::create(); @@ -255,22 +255,29 @@ TEST(Analyser, nonConstantInitialisingVariable) EXPECT_EQ_ISSUES_CELLMLELEMENTTYPES_LEVELS_REFERENCERULES_URLS(expectedIssues, expectedCellmlElementTypes(expectedIssues.size(), libcellml::CellmlElementType::VARIABLE), expectedLevels(expectedIssues.size(), libcellml::Issue::Level::ERROR), - expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_NON_CONSTANT_INITIALISATION), - expectedUrls(expectedIssues.size(), "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_NON_CONSTANT_INITIALISATION"), + expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::VARIABLE_INITIAL_VALUE_VALUE), + expectedUrls(expectedIssues.size(), "https://cellml-specification.readthedocs.io/en/latest/reference/formal_and_informative/specB08.html?issue=VARIABLE_INITIAL_VALUE_VALUE"), analyser); EXPECT_EQ(libcellml::AnalyserModel::Type::INVALID, analyser->analyserModel()->type()); } -TEST(Analyser, nonExistingInitialisingVariable) +TEST(Analyser, variableInitialisedUsingAnotherVariable) { + // Note: this should be in sync with the corresponding Generator test. + auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents("analyser/non_existing_initialising_variable.cellml")); + auto model = parser->parseModel(fileContents("analyser/variable_initialised_using_another_variable.cellml")); EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "Variable 'x' in component 'main' has an invalid initial value 'k'. Initial values must be a real number string or a variable reference.", + "Variable 'kStateStateAlgebraic' in component 'main' is initialised using variable 'kStateAlgebraic', which is an algebraic variable. Only a reference to a constant, a computed constant, a state variable, or a non-linear algebraic variable is allowed.", + "Variable 'kNlaStateAlgebraic' in component 'main' is initialised using variable 'kStateAlgebraic', which is an algebraic variable. Only a reference to a constant, a computed constant, a state variable, or a non-linear algebraic variable is allowed.", + "Variable 'xStateNlaAlgebraic' in component 'main' is initialised using variable 'kStateNlaAlgebraic', which is an algebraic variable. Only a reference to a constant, a computed constant, a state variable, or a non-linear algebraic variable is allowed.", + "Variable 'xNlaNlaAlgebraic' in component 'main' is initialised using variable 'kNlaNlaAlgebraic', which is an algebraic variable. Only a reference to a constant, a computed constant, a state variable, or a non-linear algebraic variable is allowed.", + "Variable 'xStateAlgebraic' in component 'main' is initialised using variable 'kStateAlgebraic', which is an algebraic variable. Only a reference to a constant, a computed constant, a state variable, or a non-linear algebraic variable is allowed.", + "Variable 'xNlaAlgebraic' in component 'main' is initialised using variable 'kNlaAlgebraic', which is an algebraic variable. Only a reference to a constant, a computed constant, a state variable, or a non-linear algebraic variable is allowed.", }; auto analyser = libcellml::Analyser::create(); @@ -280,8 +287,8 @@ TEST(Analyser, nonExistingInitialisingVariable) EXPECT_EQ_ISSUES_CELLMLELEMENTTYPES_LEVELS_REFERENCERULES_URLS(expectedIssues, expectedCellmlElementTypes(expectedIssues.size(), libcellml::CellmlElementType::VARIABLE), expectedLevels(expectedIssues.size(), libcellml::Issue::Level::ERROR), - expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::VARIABLE_INITIAL_VALUE_VALUE), - expectedUrls(expectedIssues.size(), "https://cellml-specification.readthedocs.io/en/latest/reference/formal_and_informative/specB08.html?issue=VARIABLE_INITIAL_VALUE_VALUE"), + expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE), + expectedUrls(expectedIssues.size(), "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE"), analyser); EXPECT_EQ(libcellml::AnalyserModel::Type::INVALID, analyser->analyserModel()->type()); @@ -347,7 +354,7 @@ TEST(Analyser, overconstrained) EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "Variable 'x' in component 'my_component' is computed more than once.", + "Variable 'x' in component 'my_component' is overconstrained.", }; auto analyser = libcellml::Analyser::create(); @@ -357,8 +364,8 @@ TEST(Analyser, overconstrained) EXPECT_EQ_ISSUES_CELLMLELEMENTTYPES_LEVELS_REFERENCERULES_URLS(expectedIssues, expectedCellmlElementTypes(expectedIssues.size(), libcellml::CellmlElementType::VARIABLE), expectedLevels(expectedIssues.size(), libcellml::Issue::Level::ERROR), - expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE), - expectedUrls(expectedIssues.size(), "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE"), + expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED), + expectedUrls(expectedIssues.size(), "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_OVERCONSTRAINED"), analyser); EXPECT_EQ(libcellml::AnalyserModel::Type::OVERCONSTRAINED, analyser->analyserModel()->type()); @@ -372,15 +379,15 @@ TEST(Analyser, unsuitablyConstrained) EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "Variable 'y' in component 'my_component' is computed more than once.", + "Variable 'y' in component 'my_component' is overconstrained.", "The type of variable 'x' in component 'my_component' is unknown.", }; const std::vector expectedReferenceRules = { - libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE, + libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED, libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNUSED, }; const std::vector expectedUrls = { - "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE", + "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_OVERCONSTRAINED", "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_UNUSED", }; @@ -905,8 +912,8 @@ TEST(Analyser, algebraicSystemWithThreeLinkedUnknownsWithOneExternalVariable) EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "Variable 'z' in component 'my_algebraic_system' is computed more than once.", - "Variable 'y' in component 'my_algebraic_system' is computed more than once.", + "Variable 'z' in component 'my_algebraic_system' is overconstrained.", + "Variable 'y' in component 'my_algebraic_system' is overconstrained.", }; auto analyser = libcellml::Analyser::create(); @@ -918,8 +925,8 @@ TEST(Analyser, algebraicSystemWithThreeLinkedUnknownsWithOneExternalVariable) EXPECT_EQ_ISSUES_CELLMLELEMENTTYPES_LEVELS_REFERENCERULES_URLS(expectedIssues, expectedCellmlElementTypes(expectedIssues.size(), libcellml::CellmlElementType::VARIABLE), expectedLevels(expectedIssues.size(), libcellml::Issue::Level::ERROR), - expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE), - expectedUrls(expectedIssues.size(), "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE"), + expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED), + expectedUrls(expectedIssues.size(), "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_OVERCONSTRAINED"), analyser); EXPECT_EQ(libcellml::AnalyserModel::Type::OVERCONSTRAINED, analyser->analyserModel()->type()); @@ -933,7 +940,7 @@ TEST(Analyser, algebraicSystemWithThreeLinkedUnknownsWithTwoExternalVariables) EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "Variable 'y' in component 'my_algebraic_system' is computed more than once.", + "Variable 'y' in component 'my_algebraic_system' is overconstrained.", }; auto analyser = libcellml::Analyser::create(); @@ -946,13 +953,40 @@ TEST(Analyser, algebraicSystemWithThreeLinkedUnknownsWithTwoExternalVariables) EXPECT_EQ_ISSUES_CELLMLELEMENTTYPES_LEVELS_REFERENCERULES_URLS(expectedIssues, expectedCellmlElementTypes(expectedIssues.size(), libcellml::CellmlElementType::VARIABLE), expectedLevels(expectedIssues.size(), libcellml::Issue::Level::ERROR), - expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE), - expectedUrls(expectedIssues.size(), "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE"), + expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED), + expectedUrls(expectedIssues.size(), "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_OVERCONSTRAINED"), analyser); EXPECT_EQ(libcellml::AnalyserModel::Type::OVERCONSTRAINED, analyser->analyserModel()->type()); } +TEST(Analyser, underconstrainedNlaSystem) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/underconstrained_nla_system.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + const std::vector expectedIssues = { + "Variable 'z' in component 'my_algebraic_system' is underconstrained.", + "Variable 'y' in component 'my_algebraic_system' is underconstrained.", + "Variable 'x' in component 'my_algebraic_system' is underconstrained.", + }; + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ_ISSUES_CELLMLELEMENTTYPES_LEVELS_REFERENCERULES_URLS(expectedIssues, + expectedCellmlElementTypes(expectedIssues.size(), libcellml::CellmlElementType::VARIABLE), + expectedLevels(expectedIssues.size(), libcellml::Issue::Level::ERROR), + expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNDERCONSTRAINED), + expectedUrls(expectedIssues.size(), "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_UNDERCONSTRAINED"), + analyser); + + EXPECT_EQ(libcellml::AnalyserModel::Type::UNDERCONSTRAINED, analyser->analyserModel()->type()); +} + TEST(Analyser, overconstrainedNlaSystem) { auto parser = libcellml::Parser::create(); @@ -961,8 +995,9 @@ TEST(Analyser, overconstrainedNlaSystem) EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedIssues = { - "Variable 'y' in component 'my_algebraic_system' is computed more than once.", - "Variable 'x' in component 'my_algebraic_system' is computed more than once.", + "Variable 'z' in component 'my_algebraic_system' is overconstrained.", + "Variable 'y' in component 'my_algebraic_system' is overconstrained.", + "Variable 'x' in component 'my_algebraic_system' is overconstrained.", }; auto analyser = libcellml::Analyser::create(); @@ -972,9 +1007,56 @@ TEST(Analyser, overconstrainedNlaSystem) EXPECT_EQ_ISSUES_CELLMLELEMENTTYPES_LEVELS_REFERENCERULES_URLS(expectedIssues, expectedCellmlElementTypes(expectedIssues.size(), libcellml::CellmlElementType::VARIABLE), expectedLevels(expectedIssues.size(), libcellml::Issue::Level::ERROR), - expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE), - expectedUrls(expectedIssues.size(), "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_COMPUTED_MORE_THAN_ONCE"), + expectedReferenceRules(expectedIssues.size(), libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED), + expectedUrls(expectedIssues.size(), "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_OVERCONSTRAINED"), analyser); EXPECT_EQ(libcellml::AnalyserModel::Type::OVERCONSTRAINED, analyser->analyserModel()->type()); } + +TEST(Analyser, unsuitablyConstrainedNlaSystem) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("analyser/unsuitably_constrained_nla_system.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + const std::vector expectedIssues = { + "Variable 'z1' in component 'my_algebraic_system' is underconstrained.", + "Variable 'y1' in component 'my_algebraic_system' is underconstrained.", + "Variable 'x1' in component 'my_algebraic_system' is underconstrained.", + "Variable 'z2' in component 'my_algebraic_system' is overconstrained.", + "Variable 'y2' in component 'my_algebraic_system' is overconstrained.", + "Variable 'x2' in component 'my_algebraic_system' is overconstrained.", + }; + const std::vector expectedReferenceRules = { + libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNDERCONSTRAINED, + libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNDERCONSTRAINED, + libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNDERCONSTRAINED, + libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED, + libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED, + libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED, + }; + const std::vector expectedUrls = { + "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_UNDERCONSTRAINED", + "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_UNDERCONSTRAINED", + "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_UNDERCONSTRAINED", + "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_OVERCONSTRAINED", + "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_OVERCONSTRAINED", + "https://libcellml.org/documentation/guides/latest/runtime_codes/index?issue=ANALYSER_VARIABLE_OVERCONSTRAINED", + }; + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + printIssues(analyser); + + EXPECT_EQ_ISSUES_CELLMLELEMENTTYPES_LEVELS_REFERENCERULES_URLS(expectedIssues, + expectedCellmlElementTypes(expectedIssues.size(), libcellml::CellmlElementType::VARIABLE), + expectedLevels(expectedIssues.size(), libcellml::Issue::Level::ERROR), + expectedReferenceRules, + expectedUrls, + analyser); + + EXPECT_EQ(libcellml::AnalyserModel::Type::UNSUITABLY_CONSTRAINED, analyser->analyserModel()->type()); +} diff --git a/tests/bindings/javascript/generatorprofile.test.js b/tests/bindings/javascript/generatorprofile.test.js index a5da78bf4..4af78e09b 100644 --- a/tests/bindings/javascript/generatorprofile.test.js +++ b/tests/bindings/javascript/generatorprofile.test.js @@ -1062,14 +1062,20 @@ describe("GeneratorProfile tests", () => { test("Checking GeneratorProfile.interfaceComputeComputedConstantsMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setInterfaceComputeComputedConstantsMethodString("something") - expect(x.interfaceComputeComputedConstantsMethodString()).toBe("something") + x.setInterfaceComputeComputedConstantsMethodString(false, "something") + expect(x.interfaceComputeComputedConstantsMethodString(false)).toBe("something") + + x.setInterfaceComputeComputedConstantsMethodString(true, "something") + expect(x.interfaceComputeComputedConstantsMethodString(true)).toBe("something") }); test("Checking GeneratorProfile.implementationComputeComputedConstantsMethodString.", () => { const x = new libcellml.GeneratorProfile(libcellml.GeneratorProfile.Profile.C) - x.setImplementationComputeComputedConstantsMethodString("something") - expect(x.implementationComputeComputedConstantsMethodString()).toBe("something") + x.setImplementationComputeComputedConstantsMethodString(false, "something") + expect(x.implementationComputeComputedConstantsMethodString(false)).toBe("something") + + x.setImplementationComputeComputedConstantsMethodString(true, "something") + expect(x.implementationComputeComputedConstantsMethodString(true)).toBe("something") }); test("Checking GeneratorProfile.interfaceComputeRatesMethodString.", () => { 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 e7e7f9012..a5d27226c 100644 --- a/tests/bindings/python/test_generator_profile.py +++ b/tests/bindings/python/test_generator_profile.py @@ -698,10 +698,15 @@ def test_implementation_compute_computed_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void computeComputedConstants(double *constants, double *computedConstants)\n{\n[CODE]}\n', - g.implementationComputeComputedConstantsMethodString()) - g.setImplementationComputeComputedConstantsMethodString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeComputedConstantsMethodString()) + self.assertEqual('void computeComputedConstants(double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', + g.implementationComputeComputedConstantsMethodString(False)) + g.setImplementationComputeComputedConstantsMethodString(False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeComputedConstantsMethodString(False)) + + self.assertEqual('void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n{\n[CODE]}\n', + g.implementationComputeComputedConstantsMethodString(True)) + g.setImplementationComputeComputedConstantsMethodString(True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationComputeComputedConstantsMethodString(True)) def test_implementation_compute_rates_method_string(self): from libcellml import GeneratorProfile @@ -944,7 +949,7 @@ def test_implementation_version_string(self): g = GeneratorProfile() - self.assertEqual('const char VERSION[] = "0.6.0";\n', g.implementationVersionString()) + self.assertEqual('const char VERSION[] = "0.7.0";\n', g.implementationVersionString()) g.setImplementationVersionString(GeneratorProfileTestCase.VALUE) self.assertEqual(GeneratorProfileTestCase.VALUE, g.implementationVersionString()) @@ -980,10 +985,15 @@ def test_interface_compute_computed_constants_method_string(self): g = GeneratorProfile() - self.assertEqual('void computeComputedConstants(double *constants, double *computedConstants);\n', - g.interfaceComputeComputedConstantsMethodString()) - g.setInterfaceComputeComputedConstantsMethodString(GeneratorProfileTestCase.VALUE) - self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeComputedConstantsMethodString()) + self.assertEqual('void computeComputedConstants(double *constants, double *computedConstants, double *algebraic);\n', + g.interfaceComputeComputedConstantsMethodString(False)) + g.setInterfaceComputeComputedConstantsMethodString(False, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeComputedConstantsMethodString(False)) + + self.assertEqual('void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n', + g.interfaceComputeComputedConstantsMethodString(True)) + g.setInterfaceComputeComputedConstantsMethodString(True, GeneratorProfileTestCase.VALUE) + self.assertEqual(GeneratorProfileTestCase.VALUE, g.interfaceComputeComputedConstantsMethodString(True)) def test_interface_compute_rates_method_string(self): from libcellml import GeneratorProfile diff --git a/tests/bindings/python/test_issue.py b/tests/bindings/python/test_issue.py index 823badef5..940cba285 100644 --- a/tests/bindings/python/test_issue.py +++ b/tests/bindings/python/test_issue.py @@ -34,9 +34,11 @@ def test_reference_rule_enum(self): 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) + self.assertIsInstance(Issue.ReferenceRule.ANALYSER_VARIABLE_UNDERCONSTRAINED, int) + self.assertIsInstance(Issue.ReferenceRule.ANALYSER_VARIABLE_OVERCONSTRAINED, int) self.assertIsInstance(Issue.ReferenceRule.ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE, int) - self.assertIsInstance(Issue.ReferenceRule.ANALYSER_VARIABLE_NON_CONSTANT_INITIALISATION, int) + self.assertIsInstance(Issue.ReferenceRule.ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE, int) + self.assertIsInstance(Issue.ReferenceRule.ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS, int) self.assertIsInstance(Issue.ReferenceRule.ANALYSER_VARIABLE_UNUSED, int) self.assertIsInstance(Issue.ReferenceRule.ANALYSER_VOI_INITIALISED, int) self.assertIsInstance(Issue.ReferenceRule.ANALYSER_VOI_SEVERAL, int) diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 10db3a7c6..ec44d63a8 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -918,7 +918,8 @@ TEST(Coverage, generator) profile->setHasInterface(true); profile->setHasPowerOperator(true); profile->setHasXorOperator(true); - profile->setImplementationComputeComputedConstantsMethodString(""); + profile->setImplementationComputeComputedConstantsMethodString(false, ""); + profile->setImplementationComputeComputedConstantsMethodString(true, ""); profile->setImplementationComputeRatesMethodString(true, ""); profile->setImplementationHeaderString("[INTERFACE_FILE_NAME]"); profile->setInterfaceFileNameString(""); diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index cd06ed823..de7a9b55b 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -1740,10 +1740,12 @@ TEST(Generator, daeModel) EXPECT_EQ_FILE_CONTENTS("generator/dae_cellml_1_1_model/model.py", generator->implementationCode(analyserModel)); } -TEST(Generator, variableInitialisedUsingAConstant) +TEST(Generator, variableInitialisedUsingAnotherVariable) { + // Note: this should be in sync with the corresponding Analyser test. + auto parser = libcellml::Parser::create(); - auto model = parser->parseModel(fileContents("generator/variable_initialised_using_a_constant/model.cellml")); + auto model = parser->parseModel(fileContents("generator/variable_initialised_using_another_variable/model.cellml")); EXPECT_EQ(size_t(0), parser->issueCount()); @@ -1756,14 +1758,14 @@ TEST(Generator, variableInitialisedUsingAConstant) auto analyserModel = analyser->analyserModel(); auto generator = libcellml::Generator::create(); - EXPECT_EQ_FILE_CONTENTS("generator/variable_initialised_using_a_constant/model.h", generator->interfaceCode(analyserModel)); - EXPECT_EQ_FILE_CONTENTS("generator/variable_initialised_using_a_constant/model.c", generator->implementationCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/variable_initialised_using_another_variable/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/variable_initialised_using_another_variable/model.c", generator->implementationCode(analyserModel)); auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); generator->setProfile(profile); - EXPECT_EQ_FILE_CONTENTS("generator/variable_initialised_using_a_constant/model.py", generator->implementationCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/variable_initialised_using_another_variable/model.py", generator->implementationCode(analyserModel)); } TEST(Generator, modelOutOfScope) diff --git a/tests/generator/generatorprofile.cpp b/tests/generator/generatorprofile.cpp index a2b5f3a09..683a9692b 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.6.0\";\n", generatorProfile->implementationVersionString()); + EXPECT_EQ("const char VERSION[] = \"0.7.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()); @@ -574,13 +574,21 @@ TEST(GeneratorProfile, defaultMiscellaneousValues) "}\n", generatorProfile->implementationInitialiseArraysMethodString(true)); - EXPECT_EQ("void computeComputedConstants(double *constants, double *computedConstants);\n", - generatorProfile->interfaceComputeComputedConstantsMethodString()); - EXPECT_EQ("void computeComputedConstants(double *constants, double *computedConstants)\n" + EXPECT_EQ("void computeComputedConstants(double *constants, double *computedConstants, double *algebraic);\n", + generatorProfile->interfaceComputeComputedConstantsMethodString(false)); + EXPECT_EQ("void computeComputedConstants(double *constants, double *computedConstants, double *algebraic)\n" "{\n" "[CODE]" "}\n", - generatorProfile->implementationComputeComputedConstantsMethodString()); + generatorProfile->implementationComputeComputedConstantsMethodString(false)); + + EXPECT_EQ("void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic);\n", + generatorProfile->interfaceComputeComputedConstantsMethodString(true)); + EXPECT_EQ("void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic)\n" + "{\n" + "[CODE]" + "}\n", + generatorProfile->implementationComputeComputedConstantsMethodString(true)); EXPECT_EQ("void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables);\n", generatorProfile->interfaceComputeRatesMethodString(false)); @@ -1054,8 +1062,11 @@ TEST(GeneratorProfile, miscellaneous) generatorProfile->setImplementationInitialiseArraysMethodString(false, value); generatorProfile->setImplementationInitialiseArraysMethodString(true, value); - generatorProfile->setInterfaceComputeComputedConstantsMethodString(value); - generatorProfile->setImplementationComputeComputedConstantsMethodString(value); + generatorProfile->setInterfaceComputeComputedConstantsMethodString(false, value); + generatorProfile->setInterfaceComputeComputedConstantsMethodString(true, value); + + generatorProfile->setImplementationComputeComputedConstantsMethodString(false, value); + generatorProfile->setImplementationComputeComputedConstantsMethodString(true, value); generatorProfile->setInterfaceComputeRatesMethodString(false, value); generatorProfile->setInterfaceComputeRatesMethodString(true, value); @@ -1206,8 +1217,11 @@ TEST(GeneratorProfile, miscellaneous) EXPECT_EQ(value, generatorProfile->interfaceInitialiseArraysMethodString(true)); EXPECT_EQ(value, generatorProfile->implementationInitialiseArraysMethodString(true)); - EXPECT_EQ(value, generatorProfile->interfaceComputeComputedConstantsMethodString()); - EXPECT_EQ(value, generatorProfile->implementationComputeComputedConstantsMethodString()); + EXPECT_EQ(value, generatorProfile->interfaceComputeComputedConstantsMethodString(false)); + EXPECT_EQ(value, generatorProfile->interfaceComputeComputedConstantsMethodString(true)); + + EXPECT_EQ(value, generatorProfile->implementationComputeComputedConstantsMethodString(false)); + EXPECT_EQ(value, generatorProfile->implementationComputeComputedConstantsMethodString(true)); EXPECT_EQ(value, generatorProfile->interfaceComputeRatesMethodString(false)); EXPECT_EQ(value, generatorProfile->implementationComputeRatesMethodString(false)); diff --git a/tests/resources/analyser/non_constant_initialising_variable.cellml b/tests/resources/analyser/non_constant_initialising_variable.cellml deleted file mode 100644 index be92d160c..000000000 --- a/tests/resources/analyser/non_constant_initialising_variable.cellml +++ /dev/null @@ -1,40 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - k2 - k1 - - - - - - - t - - x - - 1.23 - - - - - - - diff --git a/tests/resources/analyser/non_existing_initialising_variable.cellml b/tests/resources/analyser/non_existing_initialising_variable.cellml deleted file mode 100644 index 6bc6ecda3..000000000 --- a/tests/resources/analyser/non_existing_initialising_variable.cellml +++ /dev/null @@ -1,33 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - t - - x - - 1.23 - - - - - - - diff --git a/tests/resources/analyser/overconstrained_nla_system.cellml b/tests/resources/analyser/overconstrained_nla_system.cellml index 2e2f03058..1c76da7dc 100644 --- a/tests/resources/analyser/overconstrained_nla_system.cellml +++ b/tests/resources/analyser/overconstrained_nla_system.cellml @@ -1,49 +1,89 @@ + x: 1 -> 3 + y: 1 -> -2 + z: 1 -> 1 + x + y + z = 2 + 6x - 4y + 5z = 31 + 5x + 2y + 2z = 13 + -2x + y + 3z = -5--> + + + + + + x + y + z + + 2 + - 2 + 6 x - y + + + -4 + y + + + + 5 + z + - 15 + 31 - + - 3 + 5 x - y + + + 2 + y + + + + 2 + z + - 5 + 31 - x + + + -2 + x + y + + + 3 + z + - 11 + -5 diff --git a/tests/resources/analyser/underconstrained_nla_system.cellml b/tests/resources/analyser/underconstrained_nla_system.cellml new file mode 100644 index 000000000..38a29f930 --- /dev/null +++ b/tests/resources/analyser/underconstrained_nla_system.cellml @@ -0,0 +1,48 @@ + + + + + + + + + + + + + x + y + z + + 2 + + + + + + + + 6 + x + + + + -4 + y + + + + 5 + z + + + 31 + + + + diff --git a/tests/resources/analyser/unsuitably_constrained_nla_system.cellml b/tests/resources/analyser/unsuitably_constrained_nla_system.cellml new file mode 100644 index 000000000..c53a42e1f --- /dev/null +++ b/tests/resources/analyser/unsuitably_constrained_nla_system.cellml @@ -0,0 +1,133 @@ + + + + + + + + + + + + + + x1 + y1 + z1 + + 2 + + + + + + + + 6 + x1 + + + + -4 + y1 + + + + 5 + z1 + + + 31 + + + + + + + + + + + x2 + y2 + z2 + + 2 + + + + + + + + 6 + x2 + + + + -4 + y2 + + + + 5 + z2 + + + 31 + + + + + + + + 5 + x2 + + + + 2 + y2 + + + + 2 + z2 + + + 31 + + + + + + + + -2 + x2 + + y2 + + + 3 + z2 + + + -5 + + + + diff --git a/tests/resources/analyser/variable_initialised_using_a_non_existing_variable.cellml b/tests/resources/analyser/variable_initialised_using_a_non_existing_variable.cellml new file mode 100644 index 000000000..88cebc3ec --- /dev/null +++ b/tests/resources/analyser/variable_initialised_using_a_non_existing_variable.cellml @@ -0,0 +1,21 @@ + + + + + + + + + + + + + t + + x + + 1.23 + + + + diff --git a/tests/resources/analyser/variable_initialised_using_another_variable.cellml b/tests/resources/analyser/variable_initialised_using_another_variable.cellml new file mode 100644 index 000000000..46bae06b6 --- /dev/null +++ b/tests/resources/analyser/variable_initialised_using_another_variable.cellml @@ -0,0 +1,618 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + t + + xStateStateCst + + 1.23 + + + + + + + t + + kStateStateCst + + 1.23 + + + + + + + t + + xStateStateCompCst + + 1.23 + + + + + + + t + + kStateStateCompCst + + 1.23 + + + + + + + t + + xStateStateState + + 1.23 + + + + + + + t + + kStateStateState + + 1.23 + + + + + + + t + + xStateStateAlgebraic + + 1.23 + + + + + + + t + + kStateStateAlgebraic + + 1.23 + + + + + + + t + + xStateStateNla + + 1.23 + + + + + + + t + + kStateStateNla + + 1.23 + + + + + + + + + t + xNlaStateCst + + + + + + + t + + kNlaStateCst + + 1.23 + + + + t + xNlaStateCompCst + + + + + + + t + + kNlaStateCompCst + + 1.23 + + + + t + xNlaStateState + + + + + + + t + + kNlaStateState + + 1.23 + + + + t + xNlaStateAlgebraic + + + + + + + t + + kNlaStateAlgebraic + + 1.23 + + + + t + xNlaStateNla + + + + + + + t + + kNlaStateNla + + 1.23 + + + + + + + + + + + + t + + xStateNlaCst + + 1.23 + + + + t + kStateNlaCst + + + + + + + t + + xStateNlaCompCst + + 1.23 + + + + t + kStateNlaCompCst + + + + + + + t + + xStateNlaState + + 1.23 + + + + t + kStateNlaState + + + + + + + t + + xStateNlaAlgebraic + + 1.23 + + + + kStateNlaAlgebraic + t + + + + + + + t + + xStateNlaNla + + 1.23 + + + + t + kStateNlaNla + + + + + + + + + t + xNlaNlaCst + + + + t + kNlaNlaCst + + + + t + xNlaNlaCompCst + + + + t + kNlaNlaCompCst + + + + t + xNlaNlaState + + + + t + kNlaNlaState + + + + t + xNlaNlaAlgebraic + + + + kNlaNlaAlgebraic + t + + + + t + xNlaNlaNla + + + + t + kNlaNlaNla + + + + + + + + + + + + t + + xStateCst + + 1.23 + + + + + + + t + + xStateCompCst + + 1.23 + + + + kStateCompCst + + + 1.23 + kStateCst + + + + + + + + t + + xStateState + + 1.23 + + + + + + + t + + kStateState + + 1.23 + + + + + + + t + + xStateAlgebraic + + 1.23 + + + + kStateAlgebraic + t + + + + + + + t + + xStateNla + + 1.23 + + + + t + kStateNla + + + + + + + + + t + xNlaCst + + + + t + xNlaCompCst + + + + kNlaCompCst + + + 1.23 + kNlaCst + + + + + t + xNlaState + + + + + + + t + + kNlaState + + 1.23 + + + + t + xNlaAlgebraic + + + + kNlaAlgebraic + t + + + + t + xNlaNla + + + + t + kNlaNla + + + + diff --git a/tests/resources/coverage/generator/model.c b/tests/resources/coverage/generator/model.c index 48bc8bae9..fd5521da4 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -452,7 +452,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[1] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1] == constants[0]; computedConstants[1] = constants[1]/(constants[0] == constants[0]); diff --git a/tests/resources/coverage/generator/model.h b/tests/resources/coverage/generator/model.h index 0b1610cf2..9568a7de8 100644 --- a/tests/resources/coverage/generator/model.h +++ b/tests/resources/coverage/generator/model.h @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 0b6ee7a96..014dd8939 100644 --- a/tests/resources/coverage/generator/model.implementation.out +++ b/tests/resources/coverage/generator/model.implementation.out @@ -211,7 +211,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[1] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = eq(constants[1], constants[0]); computedConstants[1] = constants[1]/eq(constants[0], constants[0]); diff --git a/tests/resources/coverage/generator/model.interface.out b/tests/resources/coverage/generator/model.interface.out index 459251ef5..f7f199098 100644 --- a/tests/resources/coverage/generator/model.interface.out +++ b/tests/resources/coverage/generator/model.interface.out @@ -15,6 +15,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 12bf8f9f4..825cc7760 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.6.0.post0"; +const char VERSION[] = "0.7.0.post0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -452,7 +452,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[1] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1] == constants[0]; computedConstants[1] = constants[1]/(constants[0] == constants[0]); diff --git a/tests/resources/coverage/generator/model.modified.profile.h b/tests/resources/coverage/generator/model.modified.profile.h index 77991ad33..0a608f783 100644 --- a/tests/resources/coverage/generator/model.modified.profile.h +++ b/tests/resources/coverage/generator/model.modified.profile.h @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 16d3c08fe..76e84d822 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.5.0.post0" +__version__ = "0.6.0.post0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -419,7 +419,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[1] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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]) diff --git a/tests/resources/coverage/generator/model.no.tracking.c b/tests/resources/coverage/generator/model.no.tracking.c index 877688ff6..b5665cbcb 100644 --- a/tests/resources/coverage/generator/model.no.tracking.c +++ b/tests/resources/coverage/generator/model.no.tracking.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -221,7 +221,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[1] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/coverage/generator/model.no.tracking.h b/tests/resources/coverage/generator/model.no.tracking.h index b5b31c81d..86c60ae92 100644 --- a/tests/resources/coverage/generator/model.no.tracking.h +++ b/tests/resources/coverage/generator/model.no.tracking.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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/coverage/generator/model.out b/tests/resources/coverage/generator/model.out index d50018ceb..f705cd845 100644 --- a/tests/resources/coverage/generator/model.out +++ b/tests/resources/coverage/generator/model.out @@ -122,7 +122,7 @@ void findRoot0(double voi, double *states, double *rates, double *constants, dou algebraicVariables[1] = u[1]; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1] == constants[0]; computedConstants[1] = constants[1]/(constants[0] == constants[0]); diff --git a/tests/resources/coverage/generator/model.py b/tests/resources/coverage/generator/model.py index dbb1353a1..2176333de 100644 --- a/tests/resources/coverage/generator/model.py +++ b/tests/resources/coverage/generator/model.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -419,7 +419,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[1] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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]) 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 0d262c114..8bf4f961e 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; @@ -66,7 +66,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge computedConstants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic) { computedConstants[1] = computedConstants[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 8fae406da..ff8bcd858 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; @@ -80,7 +80,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge { } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 2fb36a41e..26566dac7 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 *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic); 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 4ed975a6e..259240b44 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 0 @@ -47,7 +47,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): pass -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(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 4dcfcab4a..bb6d32ca8 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 @@ -28,5 +28,5 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 9d19e312a..20dbcfa05 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 0 @@ -39,7 +39,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): computed_constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): computed_constants[1] = computed_constants[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 59ee86aa4..1c3c778e5 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 1; @@ -66,7 +66,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge constants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[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 4dcfcab4a..bb6d32ca8 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 @@ -28,5 +28,5 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 49883c3b6..893bc667b 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 1 @@ -39,7 +39,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): computed_constants[0] = constants[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 b06c5d19f..978140be5 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; @@ -65,7 +65,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge computedConstants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 126c1fa4f..ec9899059 100644 --- a/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_constant_on_rhs/model.h @@ -28,5 +28,5 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 9048472b8..ce891673e 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 0 @@ -38,7 +38,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): computed_constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, 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 56bd1d6f4..d47ff38ea 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -85,7 +85,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * computedConstants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *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 6b987acfa..b04e145af 100644 --- a/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 a20e58056..01035f604 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -51,7 +51,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va computed_constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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 90b199574..10fe320c6 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -85,7 +85,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * computedConstants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *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 96e644acb..94ce70879 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 04f0a3bcd..22079d115 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -51,7 +51,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va computed_constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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 919d0f708..87cc4b108 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -85,7 +85,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * computedConstants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *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 f1706e395..28cbf9e97 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 765d530d9..24b1386bc 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -51,7 +51,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va computed_constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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 e38c1c984..51d093497 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -85,7 +85,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * computedConstants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_one_component/model.h index 978a2504b..91fd15c3d 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 2a578c3b2..225a95da3 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -51,7 +51,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va computed_constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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 40fe403a2..5d76e1c8d 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; @@ -103,7 +103,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge algebraicVariables[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 f3484140c..4d2556fd0 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; @@ -119,7 +119,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge algebraicVariables[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic) { } 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 2fb36a41e..26566dac7 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 *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic); 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 049466b7a..c07550e8d 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 0 @@ -75,7 +75,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): algebraicVariables[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): 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 4dcfcab4a..bb6d32ca8 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 @@ -28,5 +28,5 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 5f14d3687..eec5b9b28 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 0 @@ -67,7 +67,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): algebraicVariables[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): 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 fdeba2473..2e57251d3 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; @@ -109,7 +109,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge algebraicVariables[2] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 1b857ca9b..bd5abe872 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 @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; @@ -81,7 +81,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge { } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic) { } 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 9d078e44a..d52fe2527 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 @@ -33,5 +33,5 @@ void deleteArray(double *array); typedef double (* ExternalVariable)(double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic); 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 2be054c9b..9281341ea 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 @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 0 @@ -48,7 +48,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): pass -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): 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 569c6e639..25248242e 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 @@ -28,5 +28,5 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 b8a9dba6c..d31e68c1d 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 0 @@ -73,7 +73,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): algebraicVariables[2] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(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 a238da57d..381aa4fba 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 2; @@ -109,7 +109,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge algebraicVariables[1] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = 3.0*constants[1]+constants[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 569c6e639..25248242e 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 @@ -28,5 +28,5 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 44f399a55..bd237fa92 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 2 @@ -73,7 +73,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): algebraicVariables[1] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): computed_constants[0] = 3.0*constants[1]+constants[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 09c61e959..7744f0b49 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 2; @@ -109,7 +109,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge algebraicVariables[1] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = 3.0*constants[1]+constants[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 569c6e639..25248242e 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 @@ -28,5 +28,5 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 44f399a55..bd237fa92 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 2 @@ -73,7 +73,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): algebraicVariables[1] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): computed_constants[0] = 3.0*constants[1]+constants[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 ed963bc27..766d46c33 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; @@ -66,7 +66,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge computedConstants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic) { computedConstants[1] = computedConstants[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 126c1fa4f..ec9899059 100644 --- a/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/algebraic_unknown_var_on_rhs/model.h @@ -28,5 +28,5 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 23749765f..71ac8681a 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 0 @@ -39,7 +39,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): computed_constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): computed_constants[1] = computed_constants[0] diff --git a/tests/resources/generator/cell_geometry_model/model.c b/tests/resources/generator/cell_geometry_model/model.c index 6157e4506..cca5884ab 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 2; @@ -69,7 +69,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge constants[1] = 0.0011; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = 1000.0*3.14*constants[1]*constants[1]*constants[0]; computedConstants[1] = 0.02*computedConstants[0]; diff --git a/tests/resources/generator/cell_geometry_model/model.external.c b/tests/resources/generator/cell_geometry_model/model.external.c index 50075b8ac..480f52c68 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 0; @@ -82,7 +82,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge { } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 996b0c5b7..5ca6ded49 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 *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic); 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 2d6901939..713e37587 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 0 @@ -49,7 +49,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): pass -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(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 4c874d7d3..ac83a1e38 100644 --- a/tests/resources/generator/cell_geometry_model/model.h +++ b/tests/resources/generator/cell_geometry_model/model.h @@ -28,5 +28,5 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 2dbeb7479..7194e2704 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 2 @@ -42,7 +42,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): constants[1] = 0.0011 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): computed_constants[0] = 1000.0*3.14*constants[1]*constants[1]*constants[0] computed_constants[1] = 0.02*computed_constants[0] diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.c b/tests/resources/generator/cellml_mappings_and_encapsulations/model.c index 472c993e5..83aeb3155 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; @@ -86,7 +86,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[1] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h index fe608b36b..a250c3ea6 100644 --- a/tests/resources/generator/cellml_mappings_and_encapsulations/model.h +++ b/tests/resources/generator/cellml_mappings_and_encapsulations/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 408edc8d3..d9b9a9e4e 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 2 @@ -52,7 +52,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[1] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/cellml_slc_example/model.py b/tests/resources/generator/cellml_slc_example/model.py index d5e8abd2e..846e029ad 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 9 @@ -55,7 +55,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): constants[8] = 1.1 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): 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]) 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 862fd4f89..cce19d524 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -84,7 +84,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[0] = constants[0]; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 c6487c76f..2e26a1fd8 100644 --- a/tests/resources/generator/cellml_state_initialised_using_variable/model.h +++ b/tests/resources/generator/cellml_state_initialised_using_variable/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 a6e1be779..e2b042ce9 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -50,7 +50,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[0] = constants[0] -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 9c8ec8a7d..dc22819b2 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 9; @@ -91,7 +91,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge constants[8] = constants[7]; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]+constants[0]; computedConstants[1] = 0.001*constants[1]+0.001*constants[0]; diff --git a/tests/resources/generator/cellml_unit_scaling_constant/model.h b/tests/resources/generator/cellml_unit_scaling_constant/model.h index 9f71954f0..a183ef741 100644 --- a/tests/resources/generator/cellml_unit_scaling_constant/model.h +++ b/tests/resources/generator/cellml_unit_scaling_constant/model.h @@ -28,5 +28,5 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 35eaab670..f85680f55 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 9 @@ -64,7 +64,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): constants[8] = constants[7] -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): 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] diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.c b/tests/resources/generator/cellml_unit_scaling_rate/model.c index 5183826b8..5c4e633af 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -84,7 +84,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[0] = 123.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/cellml_unit_scaling_rate/model.h b/tests/resources/generator/cellml_unit_scaling_rate/model.h index c6487c76f..2e26a1fd8 100644 --- a/tests/resources/generator/cellml_unit_scaling_rate/model.h +++ b/tests/resources/generator/cellml_unit_scaling_rate/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 e09640d63..9b7d90ad8 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -50,7 +50,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[0] = 123.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.c b/tests/resources/generator/cellml_unit_scaling_state/model.c index f845f9eb5..73d795648 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -84,7 +84,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[0] = 123.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/cellml_unit_scaling_state/model.h b/tests/resources/generator/cellml_unit_scaling_state/model.h index c6487c76f..2e26a1fd8 100644 --- a/tests/resources/generator/cellml_unit_scaling_state/model.h +++ b/tests/resources/generator/cellml_unit_scaling_state/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 c4bf88dee..b2454a768 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -50,7 +50,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[0] = 123.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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 05db1e4de..a65c53da8 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; @@ -84,7 +84,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[1] = 0.001*789.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 c95a25b64..d27f4f5e7 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 6dd25d580..d77590f17 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 2 @@ -50,7 +50,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[1] = 0.001*789.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 0765e8101..a7d21b7c6 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; @@ -88,7 +88,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[1] = 0.001*constants[1]; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 5f761c9c0..91b6f8df3 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 4615bfe54..61db6240c 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 2 @@ -54,7 +54,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[1] = 0.001*constants[1] -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 f71689854..71e07eb6a 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; @@ -84,7 +84,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[1] = 5.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 43d59a6ac..77fc3ba73 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_direct/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 da0cfff50..d76c8c661 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 2 @@ -50,7 +50,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[1] = 5.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 885239e91..f56b39c72 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 3; @@ -86,7 +86,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[2] = 11.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 6889a0f88..91d20c68c 100644 --- a/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h +++ b/tests/resources/generator/cellml_unit_scaling_voi_indirect/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 9db84ae67..3e2a7e1c5 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 3 @@ -52,7 +52,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[2] = 11.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 46bce59ed..a5ebbb5eb 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; @@ -165,7 +165,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[2] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *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 56c4ec8f9..3350366ae 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.h +++ b/tests/resources/generator/dae_cellml_1_1_model/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 85e0f1168..e84732552 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 2 @@ -116,7 +116,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[2] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/dependent_eqns/model.c b/tests/resources/generator/dependent_eqns/model.c index 52a35d323..4764fb652 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -84,7 +84,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[0] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/dependent_eqns/model.h b/tests/resources/generator/dependent_eqns/model.h index 72a91e08c..04fbb2071 100644 --- a/tests/resources/generator/dependent_eqns/model.h +++ b/tests/resources/generator/dependent_eqns/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 ffa8c9899..9ffd00bc2 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -50,7 +50,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[0] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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 c99065686..2bb7d60ae 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 33; @@ -454,7 +454,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[90] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[62]*constants[61]/constants[6]; computedConstants[1] = computedConstants[0]*log(constants[4]/constants[3]); 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 bb7470ed3..3a126e50d 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 0649afbd9..5dcdbd888 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 33 @@ -440,7 +440,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[90] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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 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 206a7a19e..d3dd33e91 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 15; @@ -405,7 +405,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[109] = 0.006875; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { 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]); 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 b011ffab7..115dc5443 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 d49191f67..b7702ec72 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 15 @@ -379,7 +379,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[109] = 0.006875 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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]) 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 0e84cef0a..df64cf045 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -126,7 +126,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]-10.613; computedConstants[1] = constants[1]-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 6a2c1df8d..ce6057728 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 @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 351219dc8..87c4c38f1 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -97,7 +97,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]-10.613 computed_constants[1] = constants[1]-115.0 computed_constants[2] = constants[1]+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 b1d4c789e..77bbfadd4 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -111,7 +111,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]-10.613; computedConstants[1] = constants[1]-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 5e1a8d0d0..dcd6f4146 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -126,7 +126,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]-115.0; computedConstants[1] = constants[1]+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 6a2c1df8d..ce6057728 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 @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 77394c2ad..0b2ef3ca9 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -97,7 +97,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]-115.0 computed_constants[1] = constants[1]+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 889846a3e..cbb2ec3a0 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -125,7 +125,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[3] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[0]-10.613; computedConstants[1] = constants[0]-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 6a2c1df8d..ce6057728 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 @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 b147860cd..4d168187c 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -96,7 +96,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[3] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[0]-10.613 computed_constants[1] = constants[0]-115.0 computed_constants[2] = constants[0]+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 0e7dde68a..f00efa362 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -582,7 +582,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[12] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *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 5d40e144b..1386eb196 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 @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 3; @@ -530,7 +530,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[10] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } 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 6a2c1df8d..ce6057728 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 @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 4b05be018..11a049b37 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 @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 3 @@ -449,7 +449,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[10] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.c index 196d42f6e..1d492ef11 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -528,7 +528,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[11] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]+12.0; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.h index 52fbb522e..42166250c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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.for.tracking.control.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.py index fb1b73db6..cf694f89f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -452,7 +452,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[11] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.c index c87a8517b..8d627701c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -531,7 +531,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[10] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]+12.0; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.h index 6a2c1df8d..ce6057728 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.h @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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.for.tracking.control.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.py index 3793efbf0..1a6636938 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -450,7 +450,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[10] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.c index d65b4d17f..9f29da79c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -529,7 +529,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[10] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]+12.0; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.h index 52fbb522e..42166250c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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.for.tracking.untracked.algebraic.variables.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.py index be92b021a..a0d5e4799 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -453,7 +453,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[10] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.c index a229b1f81..2378daeb5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -531,7 +531,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[10] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]+12.0; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.h index 6a2c1df8d..ce6057728 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.h @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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.for.tracking.untracked.algebraic.variables.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.py index 3793efbf0..1a6636938 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -450,7 +450,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[10] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.c index f78b32698..30b1053df 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -529,7 +529,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[11] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.h index 52fbb522e..42166250c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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.for.tracking.untracked.computed.constants.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.py index 34822c3de..8646765e4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -453,7 +453,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[11] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.c index 77fe8937b..10a0dfc65 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -531,7 +531,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[10] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]+12.0; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.h index 6a2c1df8d..ce6057728 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.h @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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.for.tracking.untracked.computed.constants.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.py index 3793efbf0..1a6636938 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -450,7 +450,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[10] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.c index d71f54f8c..684ff7842 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -530,7 +530,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[11] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { double membrane_E_R = 0.0; computedConstants[0] = membrane_E_R+12.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.h index 52fbb522e..42166250c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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.for.tracking.untracked.constants.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.py index b68bb855f..a4f28ae36 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -454,7 +454,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[11] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): membrane_E_R = 0.0 computed_constants[0] = membrane_E_R+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.c index 85eae2016..402b069e4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -531,7 +531,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[10] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { double membrane_E_R = 0.0; computedConstants[0] = membrane_E_R+12.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.h index 6a2c1df8d..ce6057728 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.h @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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.for.tracking.untracked.constants.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.py index 248dd23c8..2ba6ac032 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -450,7 +450,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[10] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): membrane_E_R = 0.0 computed_constants[0] = membrane_E_R+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.c index 0d647ca6f..7c27928bf 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -532,7 +532,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[10] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.h index 52fbb522e..42166250c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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.for.tracking.untracked.variables.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.py index 74185d068..c45b1acbe 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -456,7 +456,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[10] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.c index ac8d51a5b..01a666804 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -531,7 +531,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[10] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { double membrane_E_R = 0.0; computedConstants[0] = membrane_E_R+12.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.h index 6a2c1df8d..ce6057728 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.h @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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.for.tracking.untracked.variables.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.py index 248dd23c8..2ba6ac032 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -450,7 +450,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[10] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): membrane_E_R = 0.0 computed_constants[0] = membrane_E_R+12.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 52fbb522e..42166250c 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 fd26638f9..19e1d5d42 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -500,7 +500,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[12] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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 b927af008..8e4ccdb9c 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -126,7 +126,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]-10.613; computedConstants[1] = constants[1]-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 6a2c1df8d..ce6057728 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 @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 05eb94ed4..e6db35ecf 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -97,7 +97,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]-10.613 computed_constants[1] = constants[1]-115.0 computed_constants[2] = constants[1]+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 929550fc1..c3526688c 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -125,7 +125,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[3] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } 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 6a2c1df8d..ce6057728 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 @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 1429a1bbf..2d6d09a09 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -96,7 +96,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[3] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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 d891eb72a..56cec3ef8 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -124,7 +124,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[2] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[0]-10.613; computedConstants[1] = constants[0]-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 6a2c1df8d..ce6057728 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 @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 597f6adbc..0eecf8dae 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -95,7 +95,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[2] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[0]-10.613 computed_constants[1] = constants[0]-115.0 computed_constants[2] = constants[0]+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 2b81fde4d..fda55001d 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; @@ -124,7 +124,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]-10.613; computedConstants[1] = constants[1]-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 6a2c1df8d..ce6057728 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 @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 e48cefc1f..090628993 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 2 @@ -95,7 +95,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]-10.613 computed_constants[1] = constants[1]-115.0 computed_constants[2] = constants[1]+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 792764a3d..247e8ff16 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 3; @@ -125,7 +125,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]-10.613; computedConstants[1] = constants[1]-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 6a2c1df8d..ce6057728 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 @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 8552db8b4..c3b13c212 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 3 @@ -96,7 +96,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]-10.613 computed_constants[1] = constants[1]-115.0 computed_constants[2] = constants[1]+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 52fbb522e..42166250c 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 3a651041f..296d6f267 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -89,7 +89,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]-10.613 computed_constants[1] = constants[1]-115.0 computed_constants[2] = constants[1]+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 f59bbb56e..0a34fbaff 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 3; @@ -125,7 +125,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]-10.613; computedConstants[1] = constants[1]-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 6a2c1df8d..ce6057728 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 @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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 ab871e5b5..8a869a934 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 3 @@ -96,7 +96,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]-10.613 computed_constants[1] = constants[1]-115.0 computed_constants[2] = constants[1]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.c index bba8514d2..5916e75f6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -101,7 +101,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]-10.613; computedConstants[1] = constants[1]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.h index 1b984ef36..cfc013f3b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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.untracked.algebraic.variables.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.py index 8797775e2..970d2e57d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -79,7 +79,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]-10.613 computed_constants[1] = constants[1]-115.0 computed_constants[2] = constants[1]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.c index 8af0dc69b..ecfede2bd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -118,7 +118,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]-10.613; computedConstants[1] = constants[1]-115.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.h index 6a2c1df8d..ce6057728 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.h @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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.untracked.algebraic.variables.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.py index dfac0aa6d..cdc3538a4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -89,7 +89,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]-10.613 computed_constants[1] = constants[1]-115.0 computed_constants[2] = constants[1]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.c index ba3c6b80a..1a0f8548c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -108,7 +108,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.h index 52fbb522e..42166250c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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.untracked.computed.constants.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.py index 2cb170162..e08938232 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -86,7 +86,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.c index 9d6350003..db11b6482 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -124,7 +124,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 36.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { computedConstants[0] = constants[1]+12.0; } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.h index 6a2c1df8d..ce6057728 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.h @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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.untracked.computed.constants.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.py index d72690b5d..8121562c6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -95,7 +95,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 36.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): computed_constants[0] = constants[1]+12.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.c index 5ed2cba54..43c8bf1c4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -101,7 +101,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[3] = 0.325; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { double membrane_E_R = 0.0; computedConstants[0] = membrane_E_R-10.613; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.h index 52fbb522e..42166250c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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.untracked.constants.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.py index 4573d5870..11b5db173 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -79,7 +79,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[3] = 0.325 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): membrane_E_R = 0.0 computed_constants[0] = membrane_E_R-10.613 computed_constants[1] = membrane_E_R-115.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.c index ad1a5d03b..ea555fbb0 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -118,7 +118,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { double membrane_E_R = 0.0; computedConstants[0] = membrane_E_R-10.613; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.h index 6a2c1df8d..ce6057728 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.h @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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.untracked.constants.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.py index 650ea2028..2ad0d6571 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -89,7 +89,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): membrane_E_R = 0.0 computed_constants[0] = membrane_E_R-10.613 computed_constants[1] = membrane_E_R-115.0 diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.c index 9d7031f64..14eceb062 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -88,7 +88,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[3] = 0.325; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.h index 6b99c4c51..48c35e85f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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.untracked.variables.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.py index b1363c5f3..5d123acf2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -66,7 +66,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[3] = 0.325 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.c index 591cbc562..af325fec9 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.c @@ -5,7 +5,7 @@ #include #include -const char VERSION[] = "0.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -108,7 +108,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { double membrane_E_R = 0.0; computedConstants[0] = membrane_E_R+12.0; diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.h b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.h index 6a2c1df8d..ce6057728 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.h +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.h @@ -37,6 +37,6 @@ 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 initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic); 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.untracked.variables.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.py index f2e1c141e..417ff539b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.py @@ -4,7 +4,7 @@ from math import * -__version__ = "0.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -79,7 +79,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): membrane_E_R = 0.0 computed_constants[0] = membrane_E_R+12.0 diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 9fc9798f8..478d6313b 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 4; @@ -110,7 +110,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[4] = 40.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/noble_model_1962/model.h b/tests/resources/generator/noble_model_1962/model.h index b74431288..ab8a773bd 100644 --- a/tests/resources/generator/noble_model_1962/model.h +++ b/tests/resources/generator/noble_model_1962/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 c92f3a003..364e1e0aa 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 4 @@ -76,7 +76,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[4] = 40.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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 cf60492fe..fcc7ff203 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -84,7 +84,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * computedConstants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 43d59a6ac..77fc3ba73 100644 --- a/tests/resources/generator/ode_computed_var_on_rhs/model.h +++ b/tests/resources/generator/ode_computed_var_on_rhs/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 9d0b2be18..df9a63a65 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -50,7 +50,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va computed_constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 330c16771..1cfd3811e 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -84,7 +84,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * computedConstants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 96e644acb..94ce70879 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 94fbbc54d..a168ec78d 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -50,7 +50,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va computed_constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 bcf158ba5..aa63c71a8 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -84,7 +84,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 43d59a6ac..77fc3ba73 100644 --- a/tests/resources/generator/ode_const_var_on_rhs/model.h +++ b/tests/resources/generator/ode_const_var_on_rhs/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 40e251e63..9b8635746 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -50,7 +50,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 b2bd749a5..91ff04853 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -84,7 +84,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 96e644acb..94ce70879 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 d3f6ac0b0..fefb2b70e 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -50,7 +50,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 810d635e1..dbc6d14ed 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -82,7 +82,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 43d59a6ac..77fc3ba73 100644 --- a/tests/resources/generator/ode_constant_on_rhs/model.h +++ b/tests/resources/generator/ode_constant_on_rhs/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 4c9fb6d21..f44993163 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -48,7 +48,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 623f57694..501d29487 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -82,7 +82,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 96e644acb..94ce70879 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 f27c0dcfd..7ceec19df 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -48,7 +48,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 f4dc722df..fccb0c0fd 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; @@ -86,7 +86,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 cf9be194a..990b801ab 100644 --- a/tests/resources/generator/ode_multiple_dependent_odes/model.h +++ b/tests/resources/generator/ode_multiple_dependent_odes/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 e31e573c3..3a6e55180 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 2 @@ -52,7 +52,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 521cdf660..8bf0e0c15 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; @@ -86,7 +86,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 163aabdf6..1e0a626c6 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 815015047..63bfb2913 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 2 @@ -52,7 +52,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 9c3238c6d..6c51205d8 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; @@ -86,7 +86,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[0] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 d8e9cf382..b31ed3b01 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 @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 5078cadfe..1eb1dc56e 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 2 @@ -52,7 +52,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[0] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 290255580..0c5cd74ca 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; @@ -84,7 +84,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * states[1] = 1.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(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 43d59a6ac..77fc3ba73 100644 --- a/tests/resources/generator/ode_unknown_var_on_rhs/model.h +++ b/tests/resources/generator/ode_unknown_var_on_rhs/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 ce780d7b1..58b203c3a 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 2 @@ -50,7 +50,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va states[1] = 1.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, 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 023d556f3..a9d620fdb 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 2; @@ -131,7 +131,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * algebraicVariables[0] = 0.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.h b/tests/resources/generator/robertson_model_1966/model.dae.h index d4dc2ea10..e0920c811 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.h +++ b/tests/resources/generator/robertson_model_1966/model.dae.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 310f79c87..464d0d2c8 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 2 @@ -85,7 +85,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va algebraicVariables[0] = 0.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/robertson_model_1966/model.ode.c b/tests/resources/generator/robertson_model_1966/model.ode.c index 71cbd395c..d6d2380c0 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 3; @@ -93,7 +93,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * constants[2] = 3.0e7; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/robertson_model_1966/model.ode.h b/tests/resources/generator/robertson_model_1966/model.ode.h index d4dc2ea10..e0920c811 100644 --- a/tests/resources/generator/robertson_model_1966/model.ode.h +++ b/tests/resources/generator/robertson_model_1966/model.ode.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 e962cff99..beabee914 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 3 @@ -59,7 +59,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va constants[2] = 3.0e7 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): pass diff --git a/tests/resources/generator/sine_model_imports/model.c b/tests/resources/generator/sine_model_imports/model.c index e60f18fe4..5eb541fa9 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t STATE_COUNT = 1; @@ -99,7 +99,7 @@ void initialiseArrays(double *states, double *rates, double *constants, double * computedConstants[4] = 3.0*3.14159265358979/2.0; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) { } diff --git a/tests/resources/generator/sine_model_imports/model.h b/tests/resources/generator/sine_model_imports/model.h index 8a0bc26e6..bdf368648 100644 --- a/tests/resources/generator/sine_model_imports/model.h +++ b/tests/resources/generator/sine_model_imports/model.h @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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 d6a8ba140..635b0ebad 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" STATE_COUNT = 1 @@ -69,7 +69,7 @@ def initialise_arrays(states, rates, constants, computed_constants, algebraic_va computed_constants[4] = 3.0*3.14159265358979/2.0 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): 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 75bd0a26d..59259bcc5 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.6.0"; +const char VERSION[] = "0.7.0"; const char LIBCELLML_VERSION[] = "0.6.3"; const size_t CONSTANT_COUNT = 8; @@ -96,7 +96,7 @@ void initialiseArrays(double *constants, double *computedConstants, double *alge constants[7] = 1.1; } -void computeComputedConstants(double *constants, double *computedConstants) +void computeComputedConstants(double *constants, double *computedConstants, double *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 54a014544..75c0733e2 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 *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); void initialiseArrays(double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(double *constants, double *computedConstants, double *algebraic); 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 098399d2f..6e488c804 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.5.0" +__version__ = "0.6.0" LIBCELLML_VERSION = "0.6.3" CONSTANT_COUNT = 8 @@ -62,7 +62,7 @@ def initialise_arrays(constants, computed_constants, algebraic_variables): constants[7] = 1.1 -def compute_computed_constants(constants, computed_constants): +def compute_computed_constants(constants, computed_constants, algebraic): 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 deleted file mode 100644 index 1a45dabfe..000000000 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.c +++ /dev/null @@ -1,98 +0,0 @@ -/* The content of this file was generated using the C profile of libCellML 0.6.3. */ - -#include "model.h" - -#include -#include - -const char VERSION[] = "0.6.0"; -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_VARIABLE_COUNT = 0; - -const VariableInfo VOI_INFO = {"t", "second", "component_1"}; - -const VariableInfo STATE_INFO[] = { - {"X", "dimensionless", "component_1"} -}; - -const VariableInfo CONSTANT_INFO[] = { - {"X_init", "dimensionless", "component_2"} -}; - -const VariableInfo COMPUTED_CONSTANT_INFO[] = { -}; - -const VariableInfo ALGEBRAIC_INFO[] = { -}; - -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 * createAlgebraicVariablesArray() -{ - double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); - - for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { - res[i] = NAN; - } - - return res; -} - -void deleteArray(double *array) -{ - free(array); -} - -void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) -{ - constants[0] = 7.0; - states[0] = constants[0]; -} - -void computeComputedConstants(double *constants, double *computedConstants) -{ -} - -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 *algebraicVariables) -{ -} diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.cellml b/tests/resources/generator/variable_initialised_using_a_constant/model.cellml deleted file mode 100644 index 3439329db..000000000 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.cellml +++ /dev/null @@ -1,30 +0,0 @@ - - - - - - - - - - - - - - - - t - - X - - 3 - - - - - - - - - - diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.py b/tests/resources/generator/variable_initialised_using_a_constant/model.py deleted file mode 100644 index 2fa0eb819..000000000 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.py +++ /dev/null @@ -1,62 +0,0 @@ -# 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.3" - -STATE_COUNT = 1 -CONSTANT_COUNT = 1 -COMPUTED_CONSTANT_COUNT = 0 -ALGEBRAIC_VARIABLE_COUNT = 0 - -VOI_INFO = {"name": "t", "units": "second", "component": "component_1"} - -STATE_INFO = [ - {"name": "X", "units": "dimensionless", "component": "component_1"} -] - -CONSTANT_INFO = [ - {"name": "X_init", "units": "dimensionless", "component": "component_2"} -] - -COMPUTED_CONSTANT_INFO = [ -] - -ALGEBRAIC_INFO = [ -] - - -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_variables_array(): - return [nan]*ALGEBRAIC_VARIABLE_COUNT - - -def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): - constants[0] = 7.0 - states[0] = constants[0] - - -def compute_computed_constants(constants, computed_constants): - pass - - -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_variables): - pass diff --git a/tests/resources/generator/variable_initialised_using_another_variable/model.c b/tests/resources/generator/variable_initialised_using_another_variable/model.c new file mode 100644 index 000000000..69f212522 --- /dev/null +++ b/tests/resources/generator/variable_initialised_using_another_variable/model.c @@ -0,0 +1,817 @@ +/* The content of this file was generated using the C profile of libCellML 0.6.3. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.7.0"; +const char LIBCELLML_VERSION[] = "0.6.3"; + +const size_t STATE_COUNT = 22; +const size_t CONSTANT_COUNT = 2; +const size_t COMPUTED_CONSTANT_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 22; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "main"}; + +const VariableInfo STATE_INFO[] = { + {"xStateStateCst", "dimensionless", "main"}, + {"kStateStateCst", "dimensionless", "main"}, + {"xStateStateCompCst", "dimensionless", "main"}, + {"kStateStateCompCst", "dimensionless", "main"}, + {"xStateStateState", "dimensionless", "main"}, + {"kStateStateState", "dimensionless", "main"}, + {"xStateStateNla", "dimensionless", "main"}, + {"kStateStateNla", "dimensionless", "main"}, + {"kNlaStateCst", "dimensionless", "main"}, + {"kNlaStateCompCst", "dimensionless", "main"}, + {"kNlaStateState", "dimensionless", "main"}, + {"kNlaStateNla", "dimensionless", "main"}, + {"xStateNlaCst", "dimensionless", "main"}, + {"xStateNlaCompCst", "dimensionless", "main"}, + {"xStateNlaState", "dimensionless", "main"}, + {"xStateNlaNla", "dimensionless", "main"}, + {"xStateCst", "dimensionless", "main"}, + {"xStateCompCst", "dimensionless", "main"}, + {"xStateState", "dimensionless", "main"}, + {"kStateState", "dimensionless", "main"}, + {"xStateNla", "dimensionless", "main"}, + {"kNlaState", "dimensionless", "main"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"kStateCst", "dimensionless", "main"}, + {"kNlaCst", "dimensionless", "main"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"kStateCompCst", "dimensionless", "main"}, + {"kNlaCompCst", "dimensionless", "main"} +}; + +const VariableInfo ALGEBRAIC_INFO[] = { + {"xNlaStateCst", "dimensionless", "main"}, + {"xNlaStateCompCst", "dimensionless", "main"}, + {"xNlaStateState", "dimensionless", "main"}, + {"xNlaStateNla", "dimensionless", "main"}, + {"kStateNlaCst", "dimensionless", "main"}, + {"kStateNlaCompCst", "dimensionless", "main"}, + {"kStateNlaState", "dimensionless", "main"}, + {"kStateNlaNla", "dimensionless", "main"}, + {"xNlaNlaCst", "dimensionless", "main"}, + {"kNlaNlaCst", "dimensionless", "main"}, + {"xNlaNlaCompCst", "dimensionless", "main"}, + {"kNlaNlaCompCst", "dimensionless", "main"}, + {"xNlaNlaState", "dimensionless", "main"}, + {"kNlaNlaState", "dimensionless", "main"}, + {"xNlaNlaNla", "dimensionless", "main"}, + {"kNlaNlaNla", "dimensionless", "main"}, + {"kStateNla", "dimensionless", "main"}, + {"xNlaCst", "dimensionless", "main"}, + {"xNlaCompCst", "dimensionless", "main"}, + {"xNlaState", "dimensionless", "main"}, + {"xNlaNla", "dimensionless", "main"}, + {"kNlaNla", "dimensionless", "main"} +}; + +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 * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_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 *algebraicVariables; +} 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[0] = u[0]; + + f[0] = voi-algebraicVariables[0]; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[0]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + algebraicVariables[0] = u[0]; +} + +void objectiveFunction1(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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[1] = u[0]; + + f[0] = voi-algebraicVariables[1]; +} + +void findRoot1(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[1]; + + nlaSolve(objectiveFunction1, u, 1, &rfi); + + algebraicVariables[1] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[2] = u[0]; + + f[0] = voi-algebraicVariables[2]; +} + +void findRoot2(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[2]; + + nlaSolve(objectiveFunction2, u, 1, &rfi); + + algebraicVariables[2] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[3] = u[0]; + + f[0] = voi-algebraicVariables[3]; +} + +void findRoot3(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[3]; + + nlaSolve(objectiveFunction3, u, 1, &rfi); + + algebraicVariables[3] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[4] = u[0]; + + f[0] = voi-algebraicVariables[4]; +} + +void findRoot4(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[4]; + + nlaSolve(objectiveFunction4, u, 1, &rfi); + + algebraicVariables[4] = u[0]; +} + +void objectiveFunction5(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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[5] = u[0]; + + f[0] = voi-algebraicVariables[5]; +} + +void findRoot5(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[5]; + + nlaSolve(objectiveFunction5, u, 1, &rfi); + + algebraicVariables[5] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[6] = u[0]; + + f[0] = voi-algebraicVariables[6]; +} + +void findRoot6(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[6]; + + nlaSolve(objectiveFunction6, u, 1, &rfi); + + algebraicVariables[6] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[7] = u[0]; + + f[0] = voi-algebraicVariables[7]; +} + +void findRoot7(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[7]; + + nlaSolve(objectiveFunction7, u, 1, &rfi); + + algebraicVariables[7] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[8] = u[0]; + + f[0] = voi-algebraicVariables[8]; +} + +void findRoot8(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[8]; + + nlaSolve(objectiveFunction8, u, 1, &rfi); + + algebraicVariables[8] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[9] = u[0]; + + f[0] = voi-algebraicVariables[9]; +} + +void findRoot9(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[9]; + + nlaSolve(objectiveFunction9, u, 1, &rfi); + + algebraicVariables[9] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[10] = u[0]; + + f[0] = voi-algebraicVariables[10]; +} + +void findRoot10(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[10]; + + nlaSolve(objectiveFunction10, u, 1, &rfi); + + algebraicVariables[10] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[11] = u[0]; + + f[0] = voi-algebraicVariables[11]; +} + +void findRoot11(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[11]; + + nlaSolve(objectiveFunction11, u, 1, &rfi); + + algebraicVariables[11] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[12] = u[0]; + + f[0] = voi-algebraicVariables[12]; +} + +void findRoot12(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[12]; + + nlaSolve(objectiveFunction12, u, 1, &rfi); + + algebraicVariables[12] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[13] = u[0]; + + f[0] = voi-algebraicVariables[13]; +} + +void findRoot13(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[13]; + + nlaSolve(objectiveFunction13, u, 1, &rfi); + + algebraicVariables[13] = u[0]; +} + +void objectiveFunction14(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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[14] = u[0]; + + f[0] = voi-algebraicVariables[14]; +} + +void findRoot14(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[14]; + + nlaSolve(objectiveFunction14, u, 1, &rfi); + + algebraicVariables[14] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[15] = u[0]; + + f[0] = voi-algebraicVariables[15]; +} + +void findRoot15(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[15]; + + nlaSolve(objectiveFunction15, u, 1, &rfi); + + algebraicVariables[15] = 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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[16] = u[0]; + + f[0] = voi-algebraicVariables[16]; +} + +void findRoot16(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[16]; + + nlaSolve(objectiveFunction16, u, 1, &rfi); + + algebraicVariables[16] = u[0]; +} + +void objectiveFunction17(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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[17] = u[0]; + + f[0] = voi-algebraicVariables[17]; +} + +void findRoot17(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[17]; + + nlaSolve(objectiveFunction17, u, 1, &rfi); + + algebraicVariables[17] = u[0]; +} + +void objectiveFunction18(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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[18] = u[0]; + + f[0] = voi-algebraicVariables[18]; +} + +void findRoot18(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[18]; + + nlaSolve(objectiveFunction18, u, 1, &rfi); + + algebraicVariables[18] = u[0]; +} + +void objectiveFunction19(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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[19] = u[0]; + + f[0] = voi-algebraicVariables[19]; +} + +void findRoot19(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[19]; + + nlaSolve(objectiveFunction19, u, 1, &rfi); + + algebraicVariables[19] = u[0]; +} + +void objectiveFunction20(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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[20] = u[0]; + + f[0] = voi-algebraicVariables[20]; +} + +void findRoot20(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[20]; + + nlaSolve(objectiveFunction20, u, 1, &rfi); + + algebraicVariables[20] = u[0]; +} + +void objectiveFunction21(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 *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[21] = u[0]; + + f[0] = voi-algebraicVariables[21]; +} + +void findRoot21(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[21]; + + nlaSolve(objectiveFunction21, u, 1, &rfi); + + algebraicVariables[21] = u[0]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + constants[0] = 3.0; + states[1] = constants[0]; + states[0] = states[1]; + states[19] = 5.0; + states[5] = states[19]; + states[4] = states[5]; + algebraicVariables[16] = 7.0; + states[7] = algebraicVariables[16]; + states[6] = states[7]; + states[8] = constants[0]; + states[10] = states[19]; + states[11] = algebraicVariables[16]; + constants[1] = 3.0; + algebraicVariables[4] = constants[1]; + states[12] = algebraicVariables[4]; + states[21] = 5.0; + algebraicVariables[6] = states[21]; + states[14] = algebraicVariables[6]; + algebraicVariables[21] = 7.0; + algebraicVariables[7] = algebraicVariables[21]; + states[15] = algebraicVariables[7]; + states[16] = constants[0]; + states[18] = states[19]; + states[20] = algebraicVariables[16]; + algebraicVariables[0] = states[8]; + algebraicVariables[2] = states[10]; + algebraicVariables[3] = states[11]; + algebraicVariables[9] = constants[1]; + algebraicVariables[8] = algebraicVariables[9]; + algebraicVariables[13] = states[21]; + algebraicVariables[12] = algebraicVariables[13]; + algebraicVariables[15] = algebraicVariables[21]; + algebraicVariables[14] = algebraicVariables[15]; + algebraicVariables[17] = constants[1]; + algebraicVariables[19] = states[21]; + algebraicVariables[20] = algebraicVariables[21]; +} + +void computeComputedConstants(double *states, double *rates, double *constants, double *computedConstants, double *algebraic) +{ + computedConstants[0] = 1.23*constants[0]; + states[3] = computedConstants[0]; + states[2] = states[3]; + states[9] = computedConstants[0]; + computedConstants[1] = 1.23*constants[1]; + algebraicVariables[5] = computedConstants[1]; + states[13] = algebraicVariables[5]; + states[17] = computedConstants[0]; + algebraicVariables[1] = states[9]; + algebraicVariables[11] = computedConstants[1]; + algebraicVariables[10] = algebraicVariables[11]; + algebraicVariables[18] = computedConstants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[0] = 1.23; + rates[1] = 1.23; + rates[2] = 1.23; + rates[3] = 1.23; + rates[4] = 1.23; + rates[5] = 1.23; + rates[6] = 1.23; + rates[7] = 1.23; + rates[8] = 1.23; + rates[9] = 1.23; + rates[10] = 1.23; + rates[11] = 1.23; + rates[12] = 1.23; + rates[13] = 1.23; + rates[14] = 1.23; + rates[15] = 1.23; + rates[16] = 1.23; + rates[17] = 1.23; + rates[18] = 1.23; + rates[19] = 1.23; + rates[20] = 1.23; + rates[21] = 1.23; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot15(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot16(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot17(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot18(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot19(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot20(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot21(voi, states, rates, constants, computedConstants, algebraicVariables); +} diff --git a/tests/resources/generator/variable_initialised_using_another_variable/model.cellml b/tests/resources/generator/variable_initialised_using_another_variable/model.cellml new file mode 100644 index 000000000..8aa9c460d --- /dev/null +++ b/tests/resources/generator/variable_initialised_using_another_variable/model.cellml @@ -0,0 +1,510 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + t + + xStateStateCst + + 1.23 + + + + + + + t + + kStateStateCst + + 1.23 + + + + + + + t + + xStateStateCompCst + + 1.23 + + + + + + + t + + kStateStateCompCst + + 1.23 + + + + + + + t + + xStateStateState + + 1.23 + + + + + + + t + + kStateStateState + + 1.23 + + + + + + + t + + xStateStateNla + + 1.23 + + + + + + + t + + kStateStateNla + + 1.23 + + + + + + + + + t + xNlaStateCst + + + + + + + t + + kNlaStateCst + + 1.23 + + + + t + xNlaStateCompCst + + + + + + + t + + kNlaStateCompCst + + 1.23 + + + + t + xNlaStateState + + + + + + + t + + kNlaStateState + + 1.23 + + + + t + xNlaStateNla + + + + + + + t + + kNlaStateNla + + 1.23 + + + + + + + + + + + + t + + xStateNlaCst + + 1.23 + + + + t + kStateNlaCst + + + + + + + t + + xStateNlaCompCst + + 1.23 + + + + t + kStateNlaCompCst + + + + + + + t + + xStateNlaState + + 1.23 + + + + t + kStateNlaState + + + + + + + t + + xStateNlaNla + + 1.23 + + + + t + kStateNlaNla + + + + + + + + + t + xNlaNlaCst + + + + t + kNlaNlaCst + + + + t + xNlaNlaCompCst + + + + t + kNlaNlaCompCst + + + + t + xNlaNlaState + + + + t + kNlaNlaState + + + + t + xNlaNlaNla + + + + t + kNlaNlaNla + + + + + + + + + + + + t + + xStateCst + + 1.23 + + + + + + + t + + xStateCompCst + + 1.23 + + + + kStateCompCst + + + 1.23 + kStateCst + + + + + + + + t + + xStateState + + 1.23 + + + + + + + t + + kStateState + + 1.23 + + + + + + + t + + xStateNla + + 1.23 + + + + t + kStateNla + + + + + + + + + t + xNlaCst + + + + t + xNlaCompCst + + + + kNlaCompCst + + + 1.23 + kNlaCst + + + + + t + xNlaState + + + + + + + t + + kNlaState + + 1.23 + + + + t + xNlaNla + + + + t + kNlaNla + + + + diff --git a/tests/resources/generator/variable_initialised_using_a_constant/model.h b/tests/resources/generator/variable_initialised_using_another_variable/model.h similarity index 87% rename from tests/resources/generator/variable_initialised_using_a_constant/model.h rename to tests/resources/generator/variable_initialised_using_another_variable/model.h index 7fd5b729c..da5835c72 100644 --- a/tests/resources/generator/variable_initialised_using_a_constant/model.h +++ b/tests/resources/generator/variable_initialised_using_another_variable/model.h @@ -13,9 +13,9 @@ extern const size_t COMPUTED_CONSTANT_COUNT; extern const size_t ALGEBRAIC_VARIABLE_COUNT; typedef struct { - char name[7]; + char name[19]; char units[14]; - char component[12]; + char component[5]; } VariableInfo; extern const VariableInfo VOI_INFO; @@ -32,6 +32,6 @@ double * createAlgebraicVariablesArray(); void deleteArray(double *array); void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); -void computeComputedConstants(double *constants, double *computedConstants); +void computeComputedConstants(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_another_variable/model.py b/tests/resources/generator/variable_initialised_using_another_variable/model.py new file mode 100644 index 000000000..3c6dab99a --- /dev/null +++ b/tests/resources/generator/variable_initialised_using_another_variable/model.py @@ -0,0 +1,704 @@ +# 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.6.0" +LIBCELLML_VERSION = "0.6.3" + +STATE_COUNT = 22 +CONSTANT_COUNT = 2 +COMPUTED_CONSTANT_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 22 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "main"} + +STATE_INFO = [ + {"name": "xStateStateCst", "units": "dimensionless", "component": "main"}, + {"name": "kStateStateCst", "units": "dimensionless", "component": "main"}, + {"name": "xStateStateCompCst", "units": "dimensionless", "component": "main"}, + {"name": "kStateStateCompCst", "units": "dimensionless", "component": "main"}, + {"name": "xStateStateState", "units": "dimensionless", "component": "main"}, + {"name": "kStateStateState", "units": "dimensionless", "component": "main"}, + {"name": "xStateStateNla", "units": "dimensionless", "component": "main"}, + {"name": "kStateStateNla", "units": "dimensionless", "component": "main"}, + {"name": "kNlaStateCst", "units": "dimensionless", "component": "main"}, + {"name": "kNlaStateCompCst", "units": "dimensionless", "component": "main"}, + {"name": "kNlaStateState", "units": "dimensionless", "component": "main"}, + {"name": "kNlaStateNla", "units": "dimensionless", "component": "main"}, + {"name": "xStateNlaCst", "units": "dimensionless", "component": "main"}, + {"name": "xStateNlaCompCst", "units": "dimensionless", "component": "main"}, + {"name": "xStateNlaState", "units": "dimensionless", "component": "main"}, + {"name": "xStateNlaNla", "units": "dimensionless", "component": "main"}, + {"name": "xStateCst", "units": "dimensionless", "component": "main"}, + {"name": "xStateCompCst", "units": "dimensionless", "component": "main"}, + {"name": "xStateState", "units": "dimensionless", "component": "main"}, + {"name": "kStateState", "units": "dimensionless", "component": "main"}, + {"name": "xStateNla", "units": "dimensionless", "component": "main"}, + {"name": "kNlaState", "units": "dimensionless", "component": "main"} +] + +CONSTANT_INFO = [ + {"name": "kStateCst", "units": "dimensionless", "component": "main"}, + {"name": "kNlaCst", "units": "dimensionless", "component": "main"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "kStateCompCst", "units": "dimensionless", "component": "main"}, + {"name": "kNlaCompCst", "units": "dimensionless", "component": "main"} +] + +ALGEBRAIC_INFO = [ + {"name": "xNlaStateCst", "units": "dimensionless", "component": "main"}, + {"name": "xNlaStateCompCst", "units": "dimensionless", "component": "main"}, + {"name": "xNlaStateState", "units": "dimensionless", "component": "main"}, + {"name": "xNlaStateNla", "units": "dimensionless", "component": "main"}, + {"name": "kStateNlaCst", "units": "dimensionless", "component": "main"}, + {"name": "kStateNlaCompCst", "units": "dimensionless", "component": "main"}, + {"name": "kStateNlaState", "units": "dimensionless", "component": "main"}, + {"name": "kStateNlaNla", "units": "dimensionless", "component": "main"}, + {"name": "xNlaNlaCst", "units": "dimensionless", "component": "main"}, + {"name": "kNlaNlaCst", "units": "dimensionless", "component": "main"}, + {"name": "xNlaNlaCompCst", "units": "dimensionless", "component": "main"}, + {"name": "kNlaNlaCompCst", "units": "dimensionless", "component": "main"}, + {"name": "xNlaNlaState", "units": "dimensionless", "component": "main"}, + {"name": "kNlaNlaState", "units": "dimensionless", "component": "main"}, + {"name": "xNlaNlaNla", "units": "dimensionless", "component": "main"}, + {"name": "kNlaNlaNla", "units": "dimensionless", "component": "main"}, + {"name": "kStateNla", "units": "dimensionless", "component": "main"}, + {"name": "xNlaCst", "units": "dimensionless", "component": "main"}, + {"name": "xNlaCompCst", "units": "dimensionless", "component": "main"}, + {"name": "xNlaState", "units": "dimensionless", "component": "main"}, + {"name": "xNlaNla", "units": "dimensionless", "component": "main"}, + {"name": "kNlaNla", "units": "dimensionless", "component": "main"} +] + + +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_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_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_variables = data[5] + + algebraicVariables[0] = u[0] + + f[0] = voi-algebraicVariables[0] + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[0] + + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[0] = u[0] + + +def objective_function_1(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraicVariables[1] = u[0] + + f[0] = voi-algebraicVariables[1] + + +def find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[1] + + u = nla_solve(objective_function_1, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[1] = 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_variables = data[5] + + algebraicVariables[2] = u[0] + + f[0] = voi-algebraicVariables[2] + + +def find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[2] + + u = nla_solve(objective_function_2, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[2] = 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_variables = data[5] + + algebraicVariables[3] = u[0] + + f[0] = voi-algebraicVariables[3] + + +def find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[3] + + u = nla_solve(objective_function_3, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[3] = 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_variables = data[5] + + algebraicVariables[4] = u[0] + + f[0] = voi-algebraicVariables[4] + + +def find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[4] + + u = nla_solve(objective_function_4, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[4] = u[0] + + +def objective_function_5(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraicVariables[5] = u[0] + + f[0] = voi-algebraicVariables[5] + + +def find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[5] + + u = nla_solve(objective_function_5, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[5] = 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_variables = data[5] + + algebraicVariables[6] = u[0] + + f[0] = voi-algebraicVariables[6] + + +def find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[6] + + u = nla_solve(objective_function_6, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[6] = 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_variables = data[5] + + algebraicVariables[7] = u[0] + + f[0] = voi-algebraicVariables[7] + + +def find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[7] + + u = nla_solve(objective_function_7, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[7] = 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_variables = data[5] + + algebraicVariables[8] = u[0] + + f[0] = voi-algebraicVariables[8] + + +def find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[8] + + u = nla_solve(objective_function_8, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[8] = 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_variables = data[5] + + algebraicVariables[9] = u[0] + + f[0] = voi-algebraicVariables[9] + + +def find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[9] + + u = nla_solve(objective_function_9, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[9] = 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_variables = data[5] + + algebraicVariables[10] = u[0] + + f[0] = voi-algebraicVariables[10] + + +def find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[10] + + u = nla_solve(objective_function_10, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[10] = 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_variables = data[5] + + algebraicVariables[11] = u[0] + + f[0] = voi-algebraicVariables[11] + + +def find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[11] + + u = nla_solve(objective_function_11, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[11] = 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_variables = data[5] + + algebraicVariables[12] = u[0] + + f[0] = voi-algebraicVariables[12] + + +def find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[12] + + u = nla_solve(objective_function_12, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[12] = 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_variables = data[5] + + algebraicVariables[13] = u[0] + + f[0] = voi-algebraicVariables[13] + + +def find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[13] + + u = nla_solve(objective_function_13, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[13] = u[0] + + +def objective_function_14(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraicVariables[14] = u[0] + + f[0] = voi-algebraicVariables[14] + + +def find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[14] + + u = nla_solve(objective_function_14, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[14] = 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_variables = data[5] + + algebraicVariables[15] = u[0] + + f[0] = voi-algebraicVariables[15] + + +def find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[15] + + u = nla_solve(objective_function_15, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[15] = 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_variables = data[5] + + algebraicVariables[16] = u[0] + + f[0] = voi-algebraicVariables[16] + + +def find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[16] + + u = nla_solve(objective_function_16, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[16] = u[0] + + +def objective_function_17(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraicVariables[17] = u[0] + + f[0] = voi-algebraicVariables[17] + + +def find_root_17(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[17] + + u = nla_solve(objective_function_17, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[17] = u[0] + + +def objective_function_18(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraicVariables[18] = u[0] + + f[0] = voi-algebraicVariables[18] + + +def find_root_18(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[18] + + u = nla_solve(objective_function_18, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[18] = u[0] + + +def objective_function_19(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraicVariables[19] = u[0] + + f[0] = voi-algebraicVariables[19] + + +def find_root_19(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[19] + + u = nla_solve(objective_function_19, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[19] = u[0] + + +def objective_function_20(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraicVariables[20] = u[0] + + f[0] = voi-algebraicVariables[20] + + +def find_root_20(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[20] + + u = nla_solve(objective_function_20, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[20] = u[0] + + +def objective_function_21(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraicVariables[21] = u[0] + + f[0] = voi-algebraicVariables[21] + + +def find_root_21(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraicVariables[21] + + u = nla_solve(objective_function_21, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraicVariables[21] = u[0] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + constants[0] = 3.0 + states[1] = constants[0] + states[0] = states[1] + states[19] = 5.0 + states[5] = states[19] + states[4] = states[5] + algebraicVariables[16] = 7.0 + states[7] = algebraicVariables[16] + states[6] = states[7] + states[8] = constants[0] + states[10] = states[19] + states[11] = algebraicVariables[16] + constants[1] = 3.0 + algebraicVariables[4] = constants[1] + states[12] = algebraicVariables[4] + states[21] = 5.0 + algebraicVariables[6] = states[21] + states[14] = algebraicVariables[6] + algebraicVariables[21] = 7.0 + algebraicVariables[7] = algebraicVariables[21] + states[15] = algebraicVariables[7] + states[16] = constants[0] + states[18] = states[19] + states[20] = algebraicVariables[16] + algebraicVariables[0] = states[8] + algebraicVariables[2] = states[10] + algebraicVariables[3] = states[11] + algebraicVariables[9] = constants[1] + algebraicVariables[8] = algebraicVariables[9] + algebraicVariables[13] = states[21] + algebraicVariables[12] = algebraicVariables[13] + algebraicVariables[15] = algebraicVariables[21] + algebraicVariables[14] = algebraicVariables[15] + algebraicVariables[17] = constants[1] + algebraicVariables[19] = states[21] + algebraicVariables[20] = algebraicVariables[21] + + +def compute_computed_constants(states, rates, constants, computed_constants, algebraic): + computed_constants[0] = 1.23*constants[0] + states[3] = computed_constants[0] + states[2] = states[3] + states[9] = computed_constants[0] + computed_constants[1] = 1.23*constants[1] + algebraicVariables[5] = computed_constants[1] + states[13] = algebraicVariables[5] + states[17] = computed_constants[0] + algebraicVariables[1] = states[9] + algebraicVariables[11] = computed_constants[1] + algebraicVariables[10] = algebraicVariables[11] + algebraicVariables[18] = computed_constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[0] = 1.23 + rates[1] = 1.23 + rates[2] = 1.23 + rates[3] = 1.23 + rates[4] = 1.23 + rates[5] = 1.23 + rates[6] = 1.23 + rates[7] = 1.23 + rates[8] = 1.23 + rates[9] = 1.23 + rates[10] = 1.23 + rates[11] = 1.23 + rates[12] = 1.23 + rates[13] = 1.23 + rates[14] = 1.23 + rates[15] = 1.23 + rates[16] = 1.23 + rates[17] = 1.23 + rates[18] = 1.23 + rates[19] = 1.23 + rates[20] = 1.23 + rates[21] = 1.23 + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_1(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_4(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_11(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_14(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_17(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_18(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_19(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_20(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_21(voi, states, rates, constants, computed_constants, algebraic_variables)